@awesomeness-js/utils 1.0.24 → 1.1.2

package/package.json

@@ -1,26 +1,27 @@
 {
-    "name": "@awesomeness-js/utils",
-    "version": "1.0.24",
-    "description": "Awesomeness - Utils",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/awesomeness-js/utils.git"
-    },
-    "scripts": {
-        "prebuild": "node ./build/build.js",
-        "build": "tsc && npm run postBuild",
-        "postBuild": "node ./build/postBuild.js",
-        "test": "vitest"
-    },
-    "type": "module",
-    "types": "./types/index.d.ts",
-    "main": "index.js",
-    "author": "Scott Forte",
-    "license": "MIT",
-    "publishConfig": {
-        "access": "public"
-    },
-    "devDependencies": {
-        "vitest": "^3.0.9"
-    }
-}
+	"name": "@awesomeness-js/utils",
+	"version": "1.1.2",
+	"description": "Awesomeness - Utils",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/awesomeness-js/utils.git"
+	},
+	"scripts": {
+		"prebuild": "node ./build/build.js",
+		"build": "tsc && npm run postBuild",
+		"postBuild": "node ./build/postBuild.js",
+		"test": "vitest"
+	},
+	"type": "module",
+	"types": "./types/index.d.ts",
+	"main": "index.js",
+	"author": "Scott Forte",
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"devDependencies": {
+		"vitest": "^3.0.9",
+		"chokidar": "^4.0.3"
+	}
+}

package/schemas/schema1.js

@@ -5,7 +5,11 @@ const properties = {
 	exampleId: {
 		type: 'uuid',
 		description: 'the id of the vertex',
-		default: () => { return uuid(); },
+		default: () => {
+
+			return uuid(); 
+
+		},
 		example: '00000000-0000-0000-0000-000000000000',
 		immutable: true,
 		required: true

package/schemas/schema2.js

@@ -5,7 +5,11 @@ const properties = {
 	exampleId: {
 		type: 'uuid',
 		description: 'the id of the vertex',
-		default: () => { return uuid(); },
+		default: () => {
+
+			return uuid(); 
+
+		},
 		example: '00000000-0000-0000-0000-000000000000',
 		immutable: true,
 		required: true

package/schemas.js

@@ -9,7 +9,8 @@ import _schema2 from './schemas/schema2.js';
 export { _schema1 as schema1 };
 export { _schema2 as schema2 };
 
+
 export default {
-    schema1: _schema1,
-    schema2: _schema2,
+	schema1: _schema1,
+	schema2: _schema2,
 };

package/src/build.js

@@ -12,17 +12,97 @@
  */
 import { writeFileSync } from 'fs';
 import generateFile from './utils/generateFile.js';
+import writeHotWrapper from './utils/writeHotWrapper.js';
 
 async function build({
-    src = './src',
-    dest = './index.js',
-    exportRoots = true,
-    ignore = [],
-    includeComments = true,
-    dts = false
+	src = './src',
+	dest = './index.js',
+	exportRoots = true,
+	ignore = [],
+	includeComments = true,
+	dts = false,
+	useTabs = true,
+	hotModuleReload = false,
+	hotCallback = null,
+	hotSource = './hot-source.js'   // generated only when hot is enabled
 } = {}) {
-    writeFileSync(dest, generateFile(src, exportRoots, ignore, includeComments, dts));
-    return true;
+
+	const gen = () => generateFile({
+		src,
+		exportRoots,
+		ignore,
+		includeComments,
+		dts,
+		useTabs 
+	});
+
+	const buildHot = () => {
+
+		// 1) write payload that the wrapper imports
+		writeFileSync(hotSource, gen());
+		console.log(`[build] wrote ${hotSource}`);
+		
+		// 2) ensure index.js is a hot wrapper
+		writeHotWrapper({
+			dest,
+			hotSource 
+		});
+
+		console.log(`[build] ensured hot wrapper ${dest}`);
+	
+	};
+
+	const buildCold = () => {
+
+		// single-file classic output (no second file)
+		writeFileSync(dest, gen());
+		console.log(`[build] wrote ${dest}`);
+	
+	};
+
+	if (hotModuleReload) {
+
+		buildHot();
+
+		// watch only src; each change regenerates hot-source.js (wrapper auto-reloads it)
+		const chokidar = (await import('chokidar')).default;
+
+		console.log(`[build] watching ${src} for changes...`);
+		const watcher = chokidar.watch(src, {
+			ignoreInitial: true,
+			ignored: ignore 
+		});
+
+		let timeout;
+
+		watcher.on('all', (_event, file) => {
+
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+
+				console.log(`[build] change detected in ${file}, rebuilding payload...`);
+				writeFileSync(hotSource, gen());
+
+				if(typeof hotCallback === 'function') {
+
+					hotCallback(file);
+				
+				}
+
+				console.log(`[build] ready.`);
+			
+			}, 50);
+		
+		});
+	
+	} else {
+
+		buildCold();
+
+	}
+	
+	return true;
+
 }
 
 export default build;

package/src/clean/boolean.js

@@ -1,22 +1,32 @@
 export default function cleanBoolean(x, {
-    required = false
+	required = false
 } = {}){
 
-    try {
-    
-        if(x !== true && x !== false){
-            throw {
-                message: `Invalid boolean value "${x}"`,
-            }
-        }
-        
-        return x;
-
-    } catch (e) {
-
-        if(required) { throw e; } else { return null; }
-        
-    }
-    
+	try {
+	
+		if(x !== true && x !== false){
+
+			throw {
+				message: `Invalid boolean value "${x}"`,
+			};
+		
+		}
+		
+		return x;
+
+	} catch (e) {
+
+		if(required) {
+
+			throw e; 
+
+		} else {
+
+			return null; 
+
+		}
+		
+	}
+	
 }
 

package/src/clean/integer.js

@@ -1,74 +1,90 @@
 export default function cleanInt(x, {
-    required = false,
-    convertString = true,
-    min = false,
-    max = false,
+	required = false,
+	convertString = true,
+	min = false,
+	max = false,
 } = {}){
 
-    try {
-
-        if (typeof x !== 'number' || !Number.isInteger(x)) {
-
-            // convert string to number if possible
-            // but not a decimal string
-            if (convertString && typeof x === 'string') {
-
-                if(x.includes('.')){
-                    throw {
-                        message: 'string contains decimal',
-                        value: x
-                    };
-                }
-
-                if(!isNaN(parseInt(x))){
-                    x = parseInt(x);
-                } else {
-                    throw {
-                        message: 'string cannot be parsed to integer',
-                        value: x
-                    }
-                }
-                
-
-            } else {
-                throw {
-                    message: 'Input must be an integer',
-                    value: x
-                }
-            }
-    
-        }
-    
-        if (min !== false && x < min) { 
-        
-            throw {
-                message: `Integer must be greater than or equal to ${min}`,
-                value: x,
-                min,
-                max
-            }
-    
-        }
-    
-        if (max !== false && x > max) { 
-    
-            throw {
-                message: `Integer must be less than or equal to ${max}`,
-                value: x,
-                min,
-                max
-            }        
-    
-        }
-    
-        return x;
-
-    } catch (e) {
-
-        if(required) { throw e; } else { return null; }
-        
-    }
-    
-    
+	try {
+
+		if (typeof x !== 'number' || !Number.isInteger(x)) {
+
+			// convert string to number if possible
+			// but not a decimal string
+			if (convertString && typeof x === 'string') {
+
+				if(x.includes('.')){
+
+					throw {
+						message: 'string contains decimal',
+						value: x
+					};
+				
+				}
+
+				if(!isNaN(parseInt(x))){
+
+					x = parseInt(x);
+				
+				} else {
+
+					throw {
+						message: 'string cannot be parsed to integer',
+						value: x
+					};
+				
+				}
+				
+
+			} else {
+
+				throw {
+					message: 'Input must be an integer',
+					value: x
+				};
+			
+			}
+	
+		}
+	
+		if (min !== false && x < min) { 
+		
+			throw {
+				message: `Integer must be greater than or equal to ${min}`,
+				value: x,
+				min,
+				max
+			};
+	
+		}
+	
+		if (max !== false && x > max) { 
+	
+			throw {
+				message: `Integer must be less than or equal to ${max}`,
+				value: x,
+				min,
+				max
+			};        
+	
+		}
+	
+		return x;
+
+	} catch (e) {
+
+		if(required) {
+
+			throw e; 
+
+		} else {
+
+			return null; 
+
+		}
+		
+	}
+	
+	
 }
 

package/src/clean/number.js

@@ -1,93 +1,110 @@
 export default function cleanNumber(x, {
-    required = false,
-    convertString = true,
-    min = false,
-    max = false,
-    maxDecimal = false,
-    minDecimal = false,
+	required = false,
+	convertString = true,
+	min = false,
+	max = false,
+	maxDecimal = false,
+	minDecimal = false,
 } = {}){
 
-    try {
-
-        if (typeof x !== 'number') {
-
-            // convert string to number if possible
-            if (convertString && typeof x === 'string') {
-
-                try {
-                    x = parseFloat(x);
-                } catch(e){
-                    throw {
-                        message: 'Input cannot be parsed',
-                        value: x
-                    }
-                }
-                                
-
-                if(isNaN(x)){
-                    throw {
-                        message: 'Input cannot be parsed NaN',
-                        value: x
-                    }
-                }
-
-            } else {
-                throw {
-                    message: 'Input must be a number',
-                    value: x
-                }
-            }
-
-        }
-
-        if (min !== false && x < min) { 
-        
-            throw {
-                message: `Integer must be greater than or equal to ${min}`,
-                value: x,
-                min,
-                max
-            }
-
-        }
-
-        if (max !== false && x > max) { 
-
-            throw {
-                message: `Integer must be less than or equal to ${max}`,
-                value: x,
-                min,
-                max
-            }        
-
-        }
-
-        if (maxDecimal !== false && x.toString().split('.')[1]?.length > maxDecimal) { 
-
-            throw {
-                message: `Number must have at most ${maxDecimal} decimal places`,
-                value: x,
-                maxDecimal
-            }        
-
-        }
-
-        if (minDecimal !== false && x.toString().split('.')[1]?.length < minDecimal) {
-
-            throw {
-                message: `Number must have at least ${minDecimal} decimal places`,
-                value: x,
-                minDecimal
-            }        
-
-        }
-        
-        return x;
+	try {
+
+		if (typeof x !== 'number') {
+
+			// convert string to number if possible
+			if (convertString && typeof x === 'string') {
+
+				try {
+
+					x = parseFloat(x);
+				
+				} catch(e){
+
+					throw {
+						message: 'Input cannot be parsed',
+						value: x
+					};
+				
+				}
+								
+
+				if(isNaN(x)){
+
+					throw {
+						message: 'Input cannot be parsed NaN',
+						value: x
+					};
+				
+				}
+
+			} else {
+
+				throw {
+					message: 'Input must be a number',
+					value: x
+				};
+			
+			}
+
+		}
+
+		if (min !== false && x < min) { 
+		
+			throw {
+				message: `Integer must be greater than or equal to ${min}`,
+				value: x,
+				min,
+				max
+			};
+
+		}
+
+		if (max !== false && x > max) { 
+
+			throw {
+				message: `Integer must be less than or equal to ${max}`,
+				value: x,
+				min,
+				max
+			};        
+
+		}
+
+		if (maxDecimal !== false && x.toString().split('.')[1]?.length > maxDecimal) { 
+
+			throw {
+				message: `Number must have at most ${maxDecimal} decimal places`,
+				value: x,
+				maxDecimal
+			};        
+
+		}
+
+		if (minDecimal !== false && x.toString().split('.')[1]?.length < minDecimal) {
+
+			throw {
+				message: `Number must have at least ${minDecimal} decimal places`,
+				value: x,
+				minDecimal
+			};        
+
+		}
+		
+		return x;
   
-    } catch (e) {
+	} catch (e) {
+
+		if(required) {
+
+			throw e; 
+
+		} else {
+
+			return null; 
+
+		}
+		
+	}
 
-        if(required) { throw e; } else { return null; }
-        
-    }
 }