@awesomeness-js/server 1.1.13 → 1.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@awesomeness-js/server",
-	"version": "1.1.13",
+	"version": "1.1.14",
 	"description": "Awesomeness Multi-Site Server",
 	"author": "Scott Forte",
 	"type": "module",

package/src/componentDependencies.js

@@ -52,319 +52,322 @@ export default function componentDependencies(
 	
 	}
 
-	let componentsToProcess = [ ...allComponents ];
+	let componentsToProcess = [ ...new Set(allComponents) ];
+	const queuedComponents = new Set(componentsToProcess);
+	const processedComponents = new Set();
 	const out = {};
 
 	while (componentsToProcess.length > 0) {
 
-		const newComponentsToProcess = [];
+		const component = componentsToProcess.shift();
 
-		componentsToProcess.forEach((component) => {
+		queuedComponents.delete(component);
 
-			// Build roots in priority order; last is default because it’s last
-			const candidateRoots = componentLocations.map((baseUrl) => {
+		if (processedComponents.has(component)) {
 
-				// baseUrl should point at a directory; we resolve component under it
-				const componentUrl = new URL(`./${component}/`, baseUrl);
+			continue;
+		
+		}
 
-				
-				return path.resolve(urlToFsPath(componentUrl));
-			
-			});
+		processedComponents.add(component);
 
-			let allFiles;
-			let chosenRoot;
-			let lastErr;
+		const candidateRoots = componentLocations.map((baseUrl) => {
 
-			for (const root of candidateRoots) {
+			const componentUrl = new URL(`./${component}/`, baseUrl);
 
-				try {
+			return path.resolve(urlToFsPath(componentUrl));
+		
+		});
 
-					// IMPORTANT: pass root so getAllFiles returns paths relative to the scan root
-					allFiles = getAllFiles(".", {
-						dir: root,
-						root,
-						ignore,
-					});
+		let allFiles;
+		let chosenRoot;
+		let lastErr;
 
-					chosenRoot = root;
-					break; // first match wins
-				
-				} catch (e) {
+		for (const root of candidateRoots) {
 
-					lastErr = e;
-				
-				}
-			
-			}
+			try {
 
-			if (!allFiles) {
+				allFiles = getAllFiles(".", {
+					dir: root,
+					root,
+					ignore,
+				});
 
-				throw {
-					message: "component does not exist (no location matched)",
-					component,
-					tried: candidateRoots,
-					cause: lastErr?.message ?? lastErr,
-				};
+				chosenRoot = root;
+				break;
 			
-			}
+			} catch (e) {
 
-			if (
-				awesomenessConfig.debug_componentDependencies &&
-				Array.isArray(awesomenessConfig.debug_componentDependencies) &&
-				awesomenessConfig.debug_componentDependencies.includes(component)
-			) {
-
-				console.log("[awesomenessConfig.debug componentDependencies] chosenRoot:", chosenRoot);
-				console.log("[awesomenessConfig.debug componentDependencies] allFiles count:", allFiles.length);
-				console.log("[awesomenessConfig.debug componentDependencies] first 50 files:", allFiles.slice(0, 50));
-				console.log(
-					"[awesomenessConfig.debug componentDependencies] any non-string:",
-					allFiles.some((f) => typeof f !== "string")
-				);
-				console.log(
-					"[awesomenessConfig.debug componentDependencies] any absolute:",
-					allFiles.some((f) => path.isAbsolute(f))
-				);
+				lastErr = e;
 			
 			}
+		
+		}
 
-			allFiles.forEach((file) => {
+		if (!allFiles) {
 
-				const normalizedPath = path.normalize(file);
+			throw {
+				message: "component does not exist (no location matched)",
+				component,
+				tried: candidateRoots,
+				cause: lastErr?.message ?? lastErr,
+			};
+		
+		}
 
-				const fileNameFull = path.basename(normalizedPath);
-				const fileTypeArr = fileNameFull.split(".");
-				const fileType = fileTypeArr[fileTypeArr.length - 1].toLowerCase();
-				const fileName = fileTypeArr.slice(0, -1).join(".");
+		if (
+			awesomenessConfig.debug_componentDependencies &&
+			Array.isArray(awesomenessConfig.debug_componentDependencies) &&
+			awesomenessConfig.debug_componentDependencies.includes(component)
+		) {
+
+			console.log("[awesomenessConfig.debug componentDependencies] chosenRoot:", chosenRoot);
+			console.log("[awesomenessConfig.debug componentDependencies] allFiles count:", allFiles.length);
+			console.log("[awesomenessConfig.debug componentDependencies] first 50 files:", allFiles.slice(0, 50));
+			console.log(
+				"[awesomenessConfig.debug componentDependencies] any non-string:",
+				allFiles.some((f) => typeof f !== "string")
+			);
+			console.log(
+				"[awesomenessConfig.debug componentDependencies] any absolute:",
+				allFiles.some((f) => path.isAbsolute(f))
+			);
+		
+		}
 
-				out[component] = out[component] || {};
-				out[component][fileType] = out[component][fileType] || {};
+		allFiles.forEach((file) => {
 
-				// Build tail from the file's relative directory (NOT by searching for `component` in the path)
-				const dir = path.dirname(normalizedPath);
-				const dirParts = dir === "." ? [] : dir.split(path.sep);
+			const normalizedPath = path.normalize(file);
+			const fileNameFull = path.basename(normalizedPath);
+			const fileTypeArr = fileNameFull.split(".");
+			const fileType = fileTypeArr[fileTypeArr.length - 1].toLowerCase();
+			const fileName = fileTypeArr.slice(0, -1).join(".");
 
-				let tail = "";
+			out[component] = out[component] || {};
+			out[component][fileType] = out[component][fileType] || {};
 
-				if (fileType === "js" || fileType === "css") {
+			const dir = path.dirname(normalizedPath);
+			const dirParts = dir === "." ? [] : dir.split(path.sep);
 
-					if (dirParts.length > 0) {
+			let tail = "";
 
-						tail =
-							fileName === "index"
-								? "." + dirParts.join(".")
-								: `.${dirParts.join(".")}.${fileName}`;
-					
-					} else {
+			if (fileType === "js" || fileType === "css") {
 
-						tail = fileName === "index" ? "" : `.${fileName}`;
-					
-					}
+				if (dirParts.length > 0) {
+
+					tail = fileName === "index"
+						? "." + dirParts.join(".")
+						: `.${dirParts.join(".")}.${fileName}`;
 				
-				}
+				} else {
 
-				const componentName = `${namespace}.${component}${tail}`;
+					tail = fileName === "index" ? "" : `.${fileName}`;
+				
+				}
+			
+			}
 
-				try {
+			const componentName = `${namespace}.${component}${tail}`;
 
-					// readFileSync must use chosenRoot + relative file path
-					const filePath = path.isAbsolute(file) ? file : path.join(chosenRoot, file);
-					const fileContent = readFileMemoized(filePath);
+			try {
 
-					const lines = fileContent.split("\n");
-					let fileWithImportsStripped = "";
+				const filePath = path.isAbsolute(file) ? file : path.join(chosenRoot, file);
+				const fileContent = readFileMemoized(filePath);
 
-					try {
+				const lines = fileContent.split("\n");
+				let fileWithImportsStripped = "";
 
-						const newTest = extractUiRefsFromFileMemoized(filePath, {
-							namespace,
-							includeDotAccess: true,
-							cacheContext: `component:${component}|file:${filePath}`,
-						});
+				try {
 
-						if (newTest.length > 0) {
+					const discoveredFromContent = extractUiRefsFromFileMemoized(filePath, {
+						namespace,
+						includeDotAccess: true,
+						cacheContext: `component:${component}|file:${filePath}`,
+					});
 
-							newTest.forEach((newComp) => {
+					discoveredFromContent.forEach((newComp) => {
 
-								if (!allComponents.includes(newComp)) {
+						if (!allComponents.includes(newComp)) {
 
-									allComponents.push(newComp);
-									newComponentsToProcess.push(newComp);
-								
-								}
-							
-							});
+							allComponents.push(newComp);
 						
 						}
-					
-					} catch (error) {
 
-						console.error("Error extracting UI parts:", error);
+						if (!processedComponents.has(newComp) && !queuedComponents.has(newComp)) {
+
+							componentsToProcess.push(newComp);
+							queuedComponents.add(newComp);
+						
+						}
 					
-					}
+					});
+				
+				} catch (error) {
 
-					lines.forEach((line) => {
+					console.error("Error extracting UI parts:", error);
+				
+				}
 
-						if (line.startsWith("import ui")) {
+				lines.forEach((line) => {
 
-							if (line.includes(`import ui from '#ui'; // `)) {
+					if (line.startsWith("import ui")) {
 
-								const imports = line.split(`import ui from '#ui'; // `);
+						if (line.includes(`import ui from '#ui'; // `)) {
 
-								if (imports.length > 1) {
+							const imports = line.split(`import ui from '#ui'; // `);
 
-									const importComponents = imports[1]
-										.split(",")
-										.map((c) => c.trim());
+							if (imports.length > 1) {
 
-									importComponents.forEach((importComponent) => {
+								imports[1]
+									.split(",")
+									.map((c) => c.trim())
+									.forEach((importComponent) => {
 
 										if (!allComponents.includes(importComponent)) {
 
 											allComponents.push(importComponent);
-											newComponentsToProcess.push(importComponent);
+										
+										}
+
+										if (!processedComponents.has(importComponent) && !queuedComponents.has(importComponent)) {
+
+											componentsToProcess.push(importComponent);
+											queuedComponents.add(importComponent);
 										
 										}
 									
 									});
-								
-								}
 							
 							}
 						
-						} else if (
-							line.startsWith("// awesomeness import") ||
-							line.startsWith("/* awesomeness @import")
-						) {
+						}
+					
+					} else if (
+						line.startsWith("// awesomeness import") ||
+						line.startsWith("/* awesomeness @import")
+					) {
 
-							const importPathMatch = line.match(/['"]([^'"]+)['"]/);
+						const importPathMatch = line.match(/['"]([^'"]+)['"]/);
 
-							if (importPathMatch) {
+						if (importPathMatch) {
 
-								const importedComponentName = importPathMatch[1]
-									.replace(/;$/, "")
-									.trim();
+							const importedComponentName = importPathMatch[1].replace(/;$/, "").trim();
 
-								if (!allComponents.includes(importedComponentName)) {
+							if (!allComponents.includes(importedComponentName)) {
 
-									allComponents.push(importedComponentName);
-									newComponentsToProcess.push(importedComponentName);
-								
-								}
+								allComponents.push(importedComponentName);
 							
 							}
-						
-						} else {
 
-							fileWithImportsStripped += `${line}\n`;
+							if (!processedComponents.has(importedComponentName) && !queuedComponents.has(importedComponentName)) {
+
+								componentsToProcess.push(importedComponentName);
+								queuedComponents.add(importedComponentName);
+							
+							}
 						
 						}
 					
-					});
+					} else {
 
-					if (fileType === "js") {
+						fileWithImportsStripped += `${line}\n`;
+					
+					}
+				
+				});
 
-						if (
-							fileWithImportsStripped.startsWith("(function") ||
-							fileWithImportsStripped.startsWith("((")
-						) {
+				if (fileType === "js") {
 
-							fileWithImportsStripped = `;${fileWithImportsStripped}`;
-						
-						} else {
+					if (
+						fileWithImportsStripped.startsWith("(function") ||
+						fileWithImportsStripped.startsWith("((")
+					) {
 
-							fileWithImportsStripped = fileWithImportsStripped.replace(
-								"export default ",
-								`${componentName} = `
-							);
-						
-						}
+						fileWithImportsStripped = `;${fileWithImportsStripped}`;
 					
-					}
+					} else {
 
-					out[component][fileType][componentName] = fileWithImportsStripped;
+						fileWithImportsStripped = fileWithImportsStripped.replace(
+							"export default ",
+							`${componentName} = `
+						);
+					
+					}
 				
-				} catch (err) {
+				}
 
-					const full = path.isAbsolute(file) ? file : path.join(chosenRoot, file);
+				out[component][fileType][componentName] = fileWithImportsStripped;
+			
+			} catch (err) {
 
-					console.error("Failed to get dependencies", {
-						component,
-						file,
-						full,
-						code: err?.code,
-						message: err?.message,
-						stack: err?.stack,
-					});
-				
-				}
+				const full = path.isAbsolute(file) ? file : path.join(chosenRoot, file);
+
+				console.error("Failed to get dependencies", {
+					component,
+					file,
+					full,
+					code: err?.code,
+					message: err?.message,
+					stack: err?.stack,
+				});
 			
-			});
+			}
+		
+		});
 
-			if (out[component]) {
+		if (out[component]) {
 
-				each(out[component], (files, type) => {
+			each(out[component], (files, type) => {
 
-					if (type === "js") {
+				if (type === "js") {
 
-						const jsKeys = Object.keys(files);
+					const jsKeys = Object.keys(files);
 
-						jsKeys.forEach((key) => {
+					jsKeys.forEach((key) => {
 
-							const keyParts = key.split(".");
+						const keyParts = key.split(".");
 
-							for (let i = 2; i < keyParts.length; i++) {
+						for (let i = 2; i < keyParts.length; i++) {
 
-								const parentPath = keyParts.slice(0, i).join(".");
+							const parentPath = keyParts.slice(0, i).join(".");
 
-								if (!files[parentPath]) {
+							if (!files[parentPath]) {
 
-									files[parentPath] = `${parentPath} = ${parentPath} || {}; `;
-								
-								}
+								files[parentPath] = `${parentPath} = ${parentPath} || {}; `;
 							
 							}
 						
-						});
-
-					}
-
-					if (type === "js" && !files[`${namespace}.${component}`]) {
-
-						files[`${namespace}.${component}`] = `${namespace}.${component} = {}; `;
+						}
 					
-					}
+					});
+				
+				}
 
-					files = Object.keys(files)
-						.sort()
-						.reduce((obj, key) => {
+				if (type === "js" && !files[`${namespace}.${component}`]) {
 
-							obj[key] = files[key];
-							
-							return obj;
-						
-						}, {});
+					files[`${namespace}.${component}`] = `${namespace}.${component} = {}; `;
+				
+				}
 
-					if (showDetails) {
+				files = Object.keys(files)
+					.sort()
+					.reduce((obj, key) => {
 
-						out[component][type + "_details"] = files;
+						obj[key] = files[key];
+						
+						return obj;
 					
-					}
+					}, {});
 
-					out[component][type] = ` ${Object.values(files).join("\n")} `;
-				
-				});
-			
-			}
+				if (showDetails) {
 
-			componentsToProcess = componentsToProcess.filter((f) => f !== component);
-		
-		});
-
-		if (newComponentsToProcess.length) {
+					out[component][type + "_details"] = files;
+				
+				}
 
-			componentsToProcess = componentsToProcess.concat(newComponentsToProcess);
+				out[component][type] = ` ${Object.values(files).join("\n")} `;
+			
+			});
 		
 		}
 	

package/tests/componentDependencies.test.js

@@ -0,0 +1,85 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { pathToFileURL } from "url";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { clearComponentAndPageMemory } from "../src/componentAndPageMemory.js";
+
+const mocks = vi.hoisted(() => ({
+	getConfig: vi.fn(),
+}));
+
+vi.mock("../src/getConfig.js", () => ({
+	default: mocks.getConfig,
+}));
+
+import componentDependencies from "../src/componentDependencies.js";
+
+describe("componentDependencies", () => {
+
+	let tempRoot;
+
+	function writeComponentFile(componentName, relativeFilePath, content) {
+
+		const filePath = path.join(tempRoot, componentName, relativeFilePath);
+
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
+		fs.writeFileSync(filePath, content);
+
+	}
+
+	beforeEach(() => {
+
+		clearComponentAndPageMemory();
+		tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "awes-component-deps-"));
+		mocks.getConfig.mockReturnValue({});
+
+	});
+
+	afterEach(() => {
+
+		clearComponentAndPageMemory();
+		fs.rmSync(tempRoot, {
+			recursive: true,
+			force: true 
+		});
+		vi.clearAllMocks();
+
+	});
+
+	it("recursively resolves transitive dependencies through nested component files", () => {
+
+		writeComponentFile("alpha", "index.js", `export default function alpha() {
+	ui.beta.start();
+	return true;
+}`);
+
+		writeComponentFile("beta", path.join("nested", "index.js"), `export default function betaNested() {
+	ui.gamma.mount();
+	return true;
+}`);
+
+		writeComponentFile("gamma", path.join("deeper", "bridge.js"), `export default function gammaBridge() {
+	ui.delta.render();
+	return true;
+}`);
+
+		writeComponentFile("delta", "index.js", `export default function delta() {
+	return "done";
+}`);
+
+		const out = componentDependencies([ "alpha" ], {
+			componentLocations: [ pathToFileURL(tempRoot + path.sep) ],
+			namespace: "ui",
+		});
+
+		expect(Object.keys(out).sort()).toEqual([ "alpha", "beta", "delta", "gamma" ]);
+		expect(out.alpha.js).toContain("ui.alpha = function alpha()");
+		expect(out.beta.js).toContain("ui.beta.nested = function betaNested()");
+		expect(out.gamma.js).toContain("ui.gamma.deeper.bridge = function gammaBridge()");
+		expect(out.delta.js).toContain("ui.delta = function delta()");
+
+	});
+
+});