@awesomeness-js/utils 1.0.23 → 1.0.25

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

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