@awesomeness-js/utils 1.0.24 → 1.1.2

package/src/utils/buildExportsTree.js

@@ -1,19 +1,47 @@
 export default function buildExportsTree(fileDataList) {
-    const flatExports = [];
-    const nestedExports = {};
-    fileDataList.forEach(({ parts, functionName, importVarName, jsDocComment }) => {
-        if (parts.length === 0) {
-            flatExports.push({ functionName, importVarName, jsDocComment });
-        } else {
-            let current = nestedExports;
-            parts.forEach(part => {
-                if (!current[part]) {
-                    current[part] = {};
-                }
-                current = current[part];
-            });
-            current[functionName] = { importVarName, jsDocComment };
-        }
-    });
-    return { flatExports, nestedExports };
+
+	const flatExports = [];
+	const nestedExports = {};
+
+	fileDataList.forEach(({
+		parts, functionName, importVarName, jsDocComment 
+	}) => {
+
+		if (parts.length === 0) {
+
+			flatExports.push({
+				functionName,
+				importVarName,
+				jsDocComment 
+			});
+		
+		} else {
+
+			let current = nestedExports;
+
+			parts.forEach((part) => {
+
+				if (!current[part]) {
+
+					current[part] = {};
+				
+				}
+
+				current = current[part];
+			
+			});
+			current[functionName] = {
+				importVarName,
+				jsDocComment 
+			};
+		
+		}
+	
+	});
+	
+	return {
+		flatExports,
+		nestedExports 
+	};
+
 }

package/src/utils/buildFileDataList.js

@@ -2,22 +2,41 @@ import getAllFiles from '../getAllFiles.js';
 import extractJSDocComment from './extractJSDocComment.js';
 import { join } from 'path';
 
-export default function buildFileDataList(src, ignore, includeComments) {
-    const allFiles = getAllFiles(src, { 
-        ignore,
-        fileTypes: ['.js']
-    });
-    return allFiles.map(file => {
-        const normalizedFile = file.replace(/\\/g, '/');
-        const parts = normalizedFile.split('/');
-        const fileName = parts.pop();
-        const functionName = fileName.replace(/\.js$/, '');
-        const namespaceParts = parts;
-        const importVarName = namespaceParts.length > 0
-            ? '_' + [...namespaceParts, functionName].join('_')
-            : '_' + functionName;
-        const importPath = src + '/' + normalizedFile.replace(/\.js$/, '');
-        const jsDocComment = includeComments ? extractJSDocComment(join(src, normalizedFile)) : '';
-        return { normalizedFile, parts: namespaceParts, functionName, importVarName, importPath, jsDocComment };
-    });
+export default function buildFileDataList({
+	src, 
+	ignore, 
+	includeComments
+}) {
+
+	const allFiles = getAllFiles(src, { 
+		ignore,
+		fileTypes: [ '.js' ]
+	});
+
+    
+	return allFiles.map((file) => {
+
+		const normalizedFile = file.replace(/\\/g, '/');
+		const parts = normalizedFile.split('/');
+		const fileName = parts.pop();
+		const functionName = fileName.replace(/\.js$/, '');
+		const namespaceParts = parts;
+		const importVarName = namespaceParts.length > 0
+			? '_' + [ ...namespaceParts, functionName ].join('_')
+			: '_' + functionName;
+		const importPath = src + '/' + normalizedFile.replace(/\.js$/, '');
+		const jsDocComment = includeComments ? extractJSDocComment(join(src, normalizedFile)) : '';
+
+        
+		return {
+			normalizedFile,
+			parts: namespaceParts,
+			functionName,
+			importVarName,
+			importPath,
+			jsDocComment 
+		};
+	
+	});
+
 }

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,66 @@ 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({
+		nestedExports,
+		flatExports,
+		exportRoots,
+		dts,
+		useTabs
+	});
+    
+	return headerComment +
            importStatements + '\n' +
            namedExports + '\n' +
            defaultExportCode;
+
 }

package/src/utils/generateFlatExportLines.js

@@ -1,18 +1,41 @@
-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;
+
 }