@awesomeness-js/utils 1.0.24 → 1.0.25

package/src/utils/clean.js

@@ -11,88 +11,135 @@ import cleanUUID from '../clean/uuid.js';
 
 function cleanArray(arr, schema = {}){
 
-    try {
-
-        if(!Array.isArray(arr)) {
-            throw {
-                message: 'Input must be an array',
-                arr
-            };
-        }
+	try {
+
+		if(!Array.isArray(arr)) {
+
+			throw {
+				message: 'Input must be an array',
+				arr
+			};
+		
+		}
     
-        validateSchema(schema);
+		validateSchema(schema);
     
-        const cleanArrayItems = [];
+		const cleanArrayItems = [];
     
-        const supposedToBeType = schema.items.type;
+		const supposedToBeType = schema.items.type;
     
-        arr.forEach( (item, key) => {
+		arr.forEach( (item, key) => {
     
-            const itemType = thingType(item);
+			const itemType = thingType(item);
     
     
-            if(itemType !== supposedToBeType){
+			if(itemType !== supposedToBeType){
     
-                throw {
-                    message: 'type invalid',
-                    itemType,
-                    supposedToBeType
-                };
+				throw {
+					message: 'type invalid',
+					itemType,
+					supposedToBeType
+				};
     
-            }
+			}
     
-            let cleanedItem = item;
+			let cleanedItem = item;
     
-            if(supposedToBeType === 'boolean'){ cleanedItem = cleanBoolean(item); }
-            if(supposedToBeType === 'integer'){ cleanedItem = cleanInteger(item); }
-            if(supposedToBeType === 'number'){ cleanedItem = cleanNumber(item); }
-            if(supposedToBeType === 'string'){ cleanedItem = cleanString(item); }
-            if(supposedToBeType === 'timestamp'){ cleanedItem = cleanTimestamp(item); }
-            if(supposedToBeType === 'uuid'){ cleanedItem = cleanUUID(item); }
+			if(supposedToBeType === 'boolean'){
+
+				cleanedItem = cleanBoolean(item); 
+
+			}
+
+			if(supposedToBeType === 'integer'){
+
+				cleanedItem = cleanInteger(item); 
+
+			}
+
+			if(supposedToBeType === 'number'){
+
+				cleanedItem = cleanNumber(item); 
+
+			}
+
+			if(supposedToBeType === 'string'){
+
+				cleanedItem = cleanString(item); 
+
+			}
+
+			if(supposedToBeType === 'timestamp'){
+
+				cleanedItem = cleanTimestamp(item); 
+
+			}
+
+			if(supposedToBeType === 'uuid'){
+
+				cleanedItem = cleanUUID(item); 
+
+			}
             
-            if(supposedToBeType === 'array'){ 
-                cleanedItem = cleanArray(item, schema.items); 
-            }
-
-            if(supposedToBeType === 'object'){ 
-                cleanedItem = cleanObject(item, schema.items); 
-            }
-
-            if(cleanedItem === null){
-                if(schema.required === true){
-                    throw {
-                        message: 'required item is null',
-                        item,
-                        key
-                    };
-                } else {
-                    return; // skip this item if it's not required and is null
-                }
-            }
+			if(supposedToBeType === 'array'){
+ 
+				cleanedItem = cleanArray(item, schema.items); 
+			
+			}
+
+			if(supposedToBeType === 'object'){
+ 
+				cleanedItem = cleanObject(item, schema.items); 
+			
+			}
+
+			if(cleanedItem === null){
+
+				if(schema.required === true){
+
+					throw {
+						message: 'required item is null',
+						item,
+						key
+					};
+				
+				} else {
+
+					return; // skip this item if it's not required and is null
+				
+				}
+			
+			}
 
     
-            cleanArrayItems.push(cleanedItem);
+			cleanArrayItems.push(cleanedItem);
     
-        });
+		});
     
-        if(cleanArrayItems.length === 0){
-            throw {
-                message: 'array is empty',
-                arr
-            };
-        }
+		if(cleanArrayItems.length === 0){
+
+			throw {
+				message: 'array is empty',
+				arr
+			};
+		
+		}
+
+		return cleanArrayItems;
 
-        return cleanArrayItems;
+	} catch (e) {
 
-    } catch (e) {
+		if(schema.required === true){
 
-        if(schema.required === true){
-            throw e
-        } else {
-            return null;
-        }
+			throw e;
+		
+		} else {
 
-    }
+			return null;
+		
+		}
+
+	}
 
 
     
@@ -101,83 +148,121 @@ function cleanArray(arr, schema = {}){
 
 function cleanObject(obj, schema){
 
-    validateSchema(schema);
+	validateSchema(schema);
+
+	if(typeof obj !== 'object' || obj === null){
+
+		throw {
+			message: 'Clean Object - Input must be an object',
+			obj,
+			schema
+		};
+	
+	}
+
+	let keysPassed = Object.keys(obj);
+	let keysSchema = Object.keys(schema.properties);
+
+	const origLength = keysPassed.length;
+
+	keysPassed = keysPassed.filter((key) => keysSchema.includes(key));
+
+	if(origLength !== keysPassed.length){
+
+		throw {
+			name: 'KeyError',
+			message: 'Object contains keys not in schema',
+			keysPassed,
+			keysSchema,
+			obj
+		};
+	
+	}
+
+	const cleanObj = {};
+
+	// Iterate over the schema keys
+	each(obj, (value, key) => {
+
+		const valType = thingType(value);
+		const supposedToBeType = schema.properties[key].type;
+
+		if(valType !== supposedToBeType){
+
+			throw {
+				message: 'type invalid',
+				valType,
+				supposedToBeType,
+				key
+			};
+
+		}
+
+		let cleanedValue;
+
+		if(supposedToBeType === 'boolean'){
+
+			cleanedValue = cleanBoolean(value); 
+
+		}
+
+		if(supposedToBeType === 'integer'){
+
+			cleanedValue = cleanInteger(value); 
+
+		}
 
-    if(typeof obj !== 'object' || obj === null){
-        throw {
-            message: 'Clean Object - Input must be an object',
-            obj,
-            schema
-        };
-    }
+		if(supposedToBeType === 'number'){
 
-    let keysPassed = Object.keys(obj);
-    let keysSchema = Object.keys(schema.properties);
+			cleanedValue = cleanNumber(value); 
 
-    const origLength = keysPassed.length;
-    keysPassed = keysPassed.filter(key => keysSchema.includes(key));
+		}
 
-    if(origLength !== keysPassed.length){
-        throw {
-            name: 'KeyError',
-            message: 'Object contains keys not in schema',
-            keysPassed,
-            keysSchema,
-            obj
-        };
-    }
+		if(supposedToBeType === 'string'){
 
-    const cleanObj = {};
+			cleanedValue = cleanString(value); 
 
-    // Iterate over the schema keys
-    each(obj, (value, key) => {
+		}
 
-        const valType = thingType(value);
-        const supposedToBeType = schema.properties[key].type;
+		if(supposedToBeType === 'timestamp'){
 
-        if(valType !== supposedToBeType){
+			cleanedValue = cleanTimestamp(value); 
 
-            throw {
-                message: 'type invalid',
-                valType,
-                supposedToBeType,
-                key
-            };
+		}
 
-        }
+		if(supposedToBeType === 'uuid'){
 
-        let cleanedValue;
+			cleanedValue = cleanUUID(value); 
 
-        if(supposedToBeType === 'boolean'){ cleanedValue = cleanBoolean(value); }
-        if(supposedToBeType === 'integer'){ cleanedValue = cleanInteger(value); }
-        if(supposedToBeType === 'number'){ cleanedValue = cleanNumber(value); }
-        if(supposedToBeType === 'string'){ cleanedValue = cleanString(value); }
-        if(supposedToBeType === 'timestamp'){ cleanedValue = cleanTimestamp(value); }
-        if(supposedToBeType === 'uuid'){ cleanedValue = cleanUUID(value); }
+		}
 
-        if(supposedToBeType === 'object'){ 
-            cleanedValue = cleanObject(value, schema.properties[key]); 
-        }
+		if(supposedToBeType === 'object'){
+ 
+			cleanedValue = cleanObject(value, schema.properties[key]); 
+		
+		}
 
-        if(supposedToBeType === 'array'){ 
-            cleanedValue = cleanArray(value, schema.properties[key]); 
-        }
+		if(supposedToBeType === 'array'){
+ 
+			cleanedValue = cleanArray(value, schema.properties[key]); 
+		
+		}
 
-        cleanObj[key] = cleanedValue;
+		cleanObj[key] = cleanedValue;
 
-    });
+	});
 
-    return cleanObj;
+	return cleanObj;
 
 }
 
 export default {
-    array: cleanArray,
-    object: cleanObject,
-    boolean: cleanBoolean,
-    integer: cleanInteger,
-    number: cleanNumber,
-    string: cleanString,
-    timestamp: cleanTimestamp,
-    uuid: cleanUUID
+	array: cleanArray,
+	object: cleanObject,
+	boolean: cleanBoolean,
+	integer: cleanInteger,
+	number: cleanNumber,
+	string: cleanString,
+	timestamp: cleanTimestamp,
+	uuid: cleanUUID
 };

package/src/utils/extractJSDocComment.js

@@ -1,11 +1,18 @@
 import { readFileSync } from 'fs';
 
 export default function extractJSDocComment(filePath) {
-    const fileContent = readFileSync(filePath, 'utf8');
-    const match = fileContent.match(/\/\*\*([\s\S]*?)\*\//);
-    // If the match exists and doesn't contain an unresolved template placeholder, return it.
-    if (match && match[1] && !match[1].includes('${')) {
-        return `/**${match[1]}*/`;
-    }
-    return '';
+
+	const fileContent = readFileSync(filePath, 'utf8');
+	const match = fileContent.match(/\/\*\*([\s\S]*?)\*\//);
+
+	// If the match exists and doesn't contain an unresolved template placeholder, return it.
+
+	if (match && match[1] && !match[1].includes('${')) {
+
+		return `/**${match[1]}*/`;
+	
+	}
+
+	return '';
+
 }

package/src/utils/generateFile.js

@@ -5,30 +5,32 @@ import generateFlatExportLines from './generateFlatExportLines.js';
 import generateNamespaceExportLines from './generateNamespaceExportLines.js';
 import generateNamedExports from './generateNamedExports.js';
 
-export default function generateFile(src, exportRoots, ignore, includeComments, dts) {
-    const fileDataList = buildFileDataList(src, ignore, includeComments);
-    const { flatExports, nestedExports } = buildExportsTree(fileDataList);
-    const headerComment = `/**
+export default function generateFile(src, exportRoots, ignore, includeComments, dts, useTabs = true) {
+
+	const fileDataList = buildFileDataList(src, ignore, includeComments);
+	const {
+		flatExports, nestedExports 
+	} = buildExportsTree(fileDataList);
+	const headerComment = `/**
  * This file is auto-generated by the build script.
  * It consolidates API ${dts ? 'type declarations' : 'functions'} for use in the application.
  * Do not edit manually.
  */
 `;
-    const importStatements = generateImportStatements(fileDataList, dts, src);
-    const flatExportLines = generateFlatExportLines(flatExports, exportRoots, includeComments, dts);
-    const namespaceExportLines = generateNamespaceExportLines(nestedExports, includeComments, dts);
-    const defaultExportCode = dts
-        ? 'declare const _default: {\n' +
-          flatExportLines +
-          namespaceExportLines +
-          '};\n\nexport default _default;\n'
-        : 'export default {\n' +
-          flatExportLines +
-          namespaceExportLines +
-          '};';
-    const namedExports = generateNamedExports(flatExports, exportRoots, dts);
-    return headerComment +
+	const importStatements = generateImportStatements(fileDataList, dts, src);
+	const flatExportLines = generateFlatExportLines(flatExports, exportRoots, includeComments, dts, useTabs);
+	const namespaceExportLines = generateNamespaceExportLines(nestedExports, includeComments, dts, useTabs);
+	
+	const defaultExportCode = dts
+		? `declare const _default: {\n${flatExportLines}${namespaceExportLines}};\n\nexport default _default;\n`
+		: `export default {\n${flatExportLines}${namespaceExportLines}};`;
+
+	const namedExports = generateNamedExports(flatExports, exportRoots, dts);
+
+    
+	return headerComment +
            importStatements + '\n' +
            namedExports + '\n' +
            defaultExportCode;
+
 }

package/src/utils/generateFlatExportLines.js

@@ -1,18 +1,35 @@
-export default function generateFlatExportLines(flatExports, exportRoots, includeComments, dts) {
-    let lines = '';
-    if (exportRoots) {
-        flatExports.forEach(({ functionName, importVarName, jsDocComment }) => {
-            if (includeComments && jsDocComment) {
-                const indentedComment = jsDocComment
-                    .split('\n')
-                    .map(line => '    ' + line)
-                    .join('\n');
-                lines += indentedComment + '\n';
-            }
-            lines += dts
-                ? `    ${functionName}: typeof ${importVarName};\n`
-                : `    ${functionName}: ${importVarName},\n`;
-        });
-    }
-    return lines;
+export default function generateFlatExportLines(flatExports, exportRoots, includeComments, dts, useTabs = true) {
+
+	let indentStyle = useTabs ? '\t' : '    ';
+
+	let lines = '';
+
+
+	if (exportRoots) {
+
+		flatExports.forEach(({
+			functionName, importVarName, jsDocComment 
+		}) => {
+
+			if (includeComments && jsDocComment) {
+
+				const indentedComment = jsDocComment
+					.split('\n')
+					.map((line) => indentStyle + line)
+					.join('\n');
+
+				lines += indentedComment + '\n';
+			
+			}
+
+			lines += dts
+				? `${indentStyle}${functionName}: typeof ${importVarName};\n`
+				: `${indentStyle}${functionName}: ${importVarName},\n`;
+		
+		});
+	
+	}
+
+	return lines;
+
 }

package/src/utils/generateImportStatements.js

@@ -1,9 +1,17 @@
 export default function generateImportStatements(fileDataList, dts, src) {
-    let statements = '';
-    fileDataList.forEach(({ importVarName, importPath }) => {
-        statements += dts
-            ? `import type ${importVarName} from '.${importPath.replace(src,'')}';\n`
-            : `import ${importVarName} from '${importPath}.js';\n`;
-    });
-    return statements;
+
+	let statements = '';
+
+	fileDataList.forEach(({
+		importVarName, importPath 
+	}) => {
+
+		statements += dts
+			? `import type ${importVarName} from '.${importPath.replace(src,'')}';\n`
+			: `import ${importVarName} from '${importPath}.js';\n`;
+	
+	});
+	
+	return statements;
+
 }

package/src/utils/generateNamedExports.js

@@ -1,11 +1,22 @@
 export default function generateNamedExports(flatExports, exportRoots, dts) {
-    let lines = '';
-    if (exportRoots) {
-        flatExports.forEach(({ functionName, importVarName }) => {
-            lines += dts
-                ? `export declare const ${functionName}: typeof ${importVarName};\n`
-                : `export { ${importVarName} as ${functionName} };\n`;
-        });
-    }
-    return lines;
+
+	let lines = '';
+
+
+	if (exportRoots) {
+
+		flatExports.forEach(({
+			functionName, importVarName 
+		}) => {
+
+			lines += dts
+				? `export declare const ${functionName}: typeof ${importVarName};\n`
+				: `export { ${importVarName} as ${functionName} };\n`;
+		
+		});
+	
+	}
+
+	return lines;
+
 }

package/src/utils/generateNamespaceCode.js

@@ -1,25 +1,46 @@
-export default function generateNamespaceCode(nsObj, indentLevel, includeComments, dts) {
-    const indent = '    '.repeat(indentLevel);
-    let lines = ['{'];
-    for (const key in nsObj) {
-        const value = nsObj[key];
-        if (typeof value === 'object' && value.hasOwnProperty('importVarName')) {
-            if (includeComments && value.jsDocComment) {
-                const indentedComment = value.jsDocComment
-                    .split('\n')
-                    .map(line => indent + '    ' + line)
-                    .join('\n');
-                lines.push(indentedComment);
-            }
-            lines.push(dts
-                ? `${indent}    ${key}: typeof ${value.importVarName},`
-                : `${indent}    ${key}: ${value.importVarName},`
-            );
-        } else {
-            const nestedCode = generateNamespaceCode(value, indentLevel + 1, includeComments, dts);
-            lines.push(`${indent}    ${key}: ${nestedCode},`);
-        }
-    }
-    lines.push(indent + '}');
-    return lines.join('\n');
+export default function generateNamespaceCode(nsObj, indentLevel, includeComments, dts, useTabs = true) {
+
+	let indentStyle = useTabs ? '\t' : '    ';
+
+	const indent = indentStyle.repeat(indentLevel);
+	let lines = [ '{' ];
+
+
+	for (const key in nsObj) {
+
+		const value = nsObj[key];
+
+
+		if (typeof value === 'object' && value.hasOwnProperty('importVarName')) {
+
+			if (includeComments && value.jsDocComment) {
+
+				const indentedComment = value.jsDocComment
+					.split('\n')
+					.map((line) => indent + indentStyle + line)
+					.join('\n');
+
+				lines.push(indentedComment);
+			
+			}
+
+			lines.push(dts
+				? `${indent}${indentStyle}${key}: typeof ${value.importVarName},`
+				: `${indent}${indentStyle}${key}: ${value.importVarName},`
+			);
+		
+		} else {
+
+			const nestedCode = generateNamespaceCode(value, indentLevel + 1, includeComments, dts);
+
+			lines.push(`${indent}${indentStyle}${key}: ${nestedCode},`);
+		
+		}
+	
+	}
+
+	lines.push(indent + '}');
+	
+	return lines.join('\n');
+
 }

package/src/utils/generateNamespaceExportLines.js

@@ -1,10 +1,19 @@
 import generateNamespaceCode from './generateNamespaceCode.js';
 
-export default function generateNamespaceExportLines(nestedExports, includeComments, dts) {
-    let lines = '';
-    for (const ns in nestedExports) {
-        const nsCode = generateNamespaceCode(nestedExports[ns], 1, includeComments, dts);
-        lines += `    ${ns}: ${nsCode},\n`;
-    }
-    return lines;
+export default function generateNamespaceExportLines(nestedExports, includeComments, dts, useTabs = true) {
+
+	const indentStyle = useTabs ? '\t' : '    ';
+
+	let lines = '';
+
+	for (const ns in nestedExports) {
+
+		const nsCode = generateNamespaceCode(nestedExports[ns], 1, includeComments, dts, useTabs);
+
+		lines += `${indentStyle}${ns}: ${nsCode},\n`;
+
+	}
+
+	return lines;
+
 }