@zyrab/domo-ssg 0.2.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zyrab/domo-ssg",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A Static Site Generator (SSG) for Domo-based projects.",
   "main": "src/index.js",
   "type": "module",

package/src/config.js

@@ -1,37 +1,44 @@
 // src/config.js
 import path from "path";
+import { pathToFileURL } from "url";
+
+let mergedConfig = null;
+
+export async function loadConfig() {
+  if (mergedConfig) return mergedConfig;
+  const userConfigPath = path.resolve(process.cwd(), "domo.config.js");
 
-/**
- * Loads and processes the SSG configuration.
- * @param {string} configFilePath - Absolute path to the user's config file.
- * @returns {Promise<object>} The resolved configuration object.
- */
-export async function loadConfig(configFilePath) {
   // Default configuration values
   const defaultConfig = {
     outDir: "./dist",
-    routesFile: "./routes.js", // Assuming a common name for routes
-    layout: "./layout.js", // Assuming a common name for layout
+    routesFile: "./routes.js",
+    layout: "./layout.js",
+    lang: "en",
+    author: "Domo",
     exclude: ["css", "js", "assets", "robots.txt", "admin"],
-    baseUrl: "http://localhost:3000", // Default base URL for sitemap
+    baseUrl: "http://localhost:3000",
   };
 
   let userConfig = {};
   try {
-    const importedConfig = await import(configFilePath);
+    const importedConfig = await import(pathToFileURL(userConfigPath).href);
     userConfig = importedConfig.default || importedConfig;
   } catch (error) {
     console.warn(`⚠️  No custom config file found at ${configFilePath}. Using default settings.`);
   }
+  mergedConfig = {
+    ...defaultConfig,
+    ...userConfig,
+    outDir: path.resolve(process.cwd(), userConfig.outDir || defaultConfig.outDir),
+    routesFile: path.resolve(process.cwd(), userConfig.routesFile || defaultConfig.routesFile),
+    layout: path.resolve(process.cwd(), userConfig.layout || defaultConfig.layout),
+  };
+  return mergedConfig;
+}
 
-  // Merge user config with defaults
-  const mergedConfig = { ...defaultConfig, ...userConfig };
-
-  // Resolve paths relative to the current working directory of the build script
-  // This assumes the config file itself specifies paths relative to its own location
-  mergedConfig.outDir = path.resolve(process.cwd(), mergedConfig.outDir);
-  mergedConfig.routesFile = path.resolve(process.cwd(), mergedConfig.routesFile);
-  mergedConfig.layout = path.resolve(process.cwd(), mergedConfig.layout);
-
+export function getConfig() {
+  if (!mergedConfig) {
+    throw new Error("Config has not been loaded yet. Call loadConfig() first.");
+  }
   return mergedConfig;
 }

package/src/index.js

@@ -1,19 +1,12 @@
-// src/index.js (formerly build.mjs)
+// src/index.js
 import { pathToFileURL } from "url";
-import path from "path";
 import { loadConfig } from "./config.js";
 import { cleanOutputDir } from "./file-utils.js";
 import { generateSitemap } from "./sitemap.js";
 import { buildRoutes } from "./route-traversal.js";
 
-// __filename and __dirname equivalents for ES Modules
-
 async function main() {
-  // Determine where the user's config file should be
-  // Assumes config is at the root of the project where the script is run
-  const userConfigPath = path.resolve(process.cwd(), "domo.config.js");
-
-  const config = await loadConfig(pathToFileURL(userConfigPath).href);
+  const config = await loadConfig();
 
   // Import layout and route tree using pathToFileURL and .href for dynamic imports
   const { routes } = await import(pathToFileURL(config.routesFile).href);
@@ -28,7 +21,7 @@ async function main() {
   cleanOutputDir(config.outDir, config.exclude);
 
   // 2. Build all routes recursively
-  await buildRoutes(routes, "", {}, renderLayout, config.outDir);
+  await buildRoutes(routes, renderLayout);
 
   // 3. Generate sitemap
   generateSitemap(config.outDir, config.baseUrl, config.exclude);

package/src/route-handler.js

@@ -1,5 +1,6 @@
 // src/route-handler.js
 import Router from "@zyrab/domo-router";
+import { getConfig } from "./config.js";
 import { writeHTML } from "./file-utils.js";
 import { writeJs } from "./event-utils.js";
 
@@ -16,7 +17,6 @@ export function joinPaths(...segments) {
 
   return "/" + pathStr.replace(/\/+/g, "/");
 }
-
 /**
  * Handles the rendering and writing of a single route's HTML file.
  * @param {object} routeConfig - Configuration for the current route.
@@ -26,42 +26,55 @@ export function joinPaths(...segments) {
  * @param {string} [routeConfig.script] - Optional script to include in the layout.
  * @param {object} [routeConfig.meta={}] - Optional metadata for the page (title, description).
  * @param {Function} renderLayout - The layout rendering function from the user's config.
- * @param {string} outputDir - The base output directory for generated files.
  * @returns {Promise<void>}
  */
 
-export async function handleRoute({ path, props, component, script, meta = {} }, renderLayout, outputDir) {
+export async function handleRoute({ path, props, component, scripts, styles, fonts, meta = {} }, renderLayout) {
+  const config = getConfig();
   try {
     // Set router info for server-side context
     Router.setInfo(path, props);
 
-    // Calculate base depth for relative paths in layout if needed
-    const baseDepth = path === "/" ? 0 : path.split("/").filter(Boolean).length;
-
     // Render the component content
     const content = await component(props);
 
     // --- Write JS file ---
-    const eScript = writeJs(content, outputDir, path);
-    let allScript = [];
-    if (Array.isArray(script) && script.length > 0) {
-      allScript.push(...script);
-    }
-    if (eScript && typeof eScript === "string" && eScript.trim() !== "") {
-      allScript.push(eScript);
-    }
+    const embededScript = writeJs(content, config.outDir, path);
 
+    const fontPaths = normalizeAssets([fonts, config.assets.fonts]);
+    const stylePaths = normalizeAssets([styles, config.assets.styles]);
+    const scriptPaths = normalizeAssets([embededScript, scripts, config.assets.scripts]);
     // Render the full HTML layout
     const html = await renderLayout(content, {
       title: meta.title || "",
       description: meta.description || "",
-      script: allScript,
-      baseDepth,
+      descriptionOG: meta.descriptionOG,
+      canonical: meta.canonical,
+      type: meta.type,
+      scripts: scriptPaths,
+      styles: stylePaths,
+      fonts: fontPaths,
+      favicon: config?.assets?.favicon,
+      baseUrl: config?.baseUrl,
+      lang: config?.lang,
+      author: config?.author,
+      theme: config?.theme,
     });
 
     // Write the generated HTML to a file
-    writeHTML(outputDir, path, html);
+    writeHTML(config.outDir, path, html);
   } catch (e) {
     console.warn(`⚠️  Error rendering ${path}:\n${e.stack}`);
   }
 }
+function normalizeAssets(arr) {
+  let result = [];
+  for (const el of arr) {
+    if (Array.isArray(el) && el.length > 0) {
+      result.push(...el);
+    } else if (typeof el === "string" && el.trim() !== "") {
+      result.push(el);
+    }
+  }
+  return result;
+}

package/src/route-traversal.js

@@ -4,77 +4,58 @@ import { handleRoute, joinPaths } from "./route-handler.js";
 /**
  * Recursively builds HTML files for all defined routes, including nested and dynamic routes.
  * @param {object} routes - The route configuration object.
+ * @param {Function} renderLayout - The layout rendering function.
  * @param {string} [parentPath=""] - The path accumulated from parent routes.
  * @param {object} [props={}] - Accumulated properties from parent dynamic routes.
- * @param {Function} renderLayout - The layout rendering function.
- * @param {string} outputDir - The base output directory.
- * @returns {Promise<void>}
  */
-export async function buildRoutes(routes, parentPath = "", props = {}, renderLayout, outputDir) {
-  for (const routeKey in routes) {
-    const r = routes[routeKey];
+export async function buildRoutes(routes, renderLayout, parentPath = "", props = {}) {
+  for (const routeSegment in routes) {
+    const routeNode = routes[routeSegment];
     // Skip '/' if it's a child of another path (handled by parent's segment)
-    if (parentPath !== "" && routeKey === "/") continue;
+    if (parentPath !== "" && routeSegment === "/") continue;
 
-    // Handle dynamic routes with getDinamicList
-    if (r.getDinamicList) {
+    const currentRoute = joinPaths(parentPath, routeSegment);
+    // Handle dynamic routes with routeParams
+    if (routeNode.routeParams) {
       try {
         // Extract parameter name from dynamic segment (e.g., ":slug" -> "slug")
-        const paramKey = routeKey.split(":").filter(Boolean).pop();
+        const paramName = routeSegment.split(":").filter(Boolean).pop();
         // The last segment of the parent path is the slug for nested dynamic lists
-        const slugParam = parentPath.split("/").filter(Boolean).pop();
+        const parentRouteName = parentPath.split("/").filter(Boolean).pop();
 
-        const list = await r.getDinamicList(slugParam);
+        const resolvedParams = await routeNode.routeParams(parentRouteName);
 
-        if (!Array.isArray(list) || list.length === 0) {
-          console.warn(`⚠️  No items returned for dynamic route at ${joinPaths(parentPath, routeKey)}`);
+        if (!Array.isArray(resolvedParams) || resolvedParams.length === 0) {
+          console.warn(`⚠️  No items returned for dynamic route at ${currentRoute}`);
           continue;
         }
 
-        for (const item of list) {
-          if (!item[paramKey]) {
-            console.warn(
-              `⚠️  Missing required parameter '${paramKey}' in item for dynamic route at ${joinPaths(
-                parentPath,
-                routeKey
-              )}`
-            );
+        for (const item of resolvedParams) {
+          if (!item[paramName]) {
+            console.warn(`⚠️  Missing required parameter '${paramName}' in item for dynamic route at ${currentRoute}`);
             continue;
           }
 
-          const segment = item[paramKey]; // Use the actual value from the item for the URL segment
-          const meta = { title: item.title, description: item.description, ...item.meta }; // Merge item's meta with route's meta
+          const segment = item[paramName]; // Use the actual value from the item for the URL segment
+          const meta = {
+            title: item.title,
+            description: item.description,
+            type: item?.type,
+            canonical: item?.canonical,
+            ogImage: item?.ogImage,
+            descriptionOG: item?.descriptionOG,
+          }; // Merge item's meta with route's meta
           const routePath = joinPaths(parentPath, segment); // Full path for this specific dynamic item
-          const childProps = { ...props, [paramKey]: segment, itemData: item }; // Pass item data as prop
+          const childProps = { ...props, [paramName]: segment, itemData: item }; // Pass item data as prop
 
-          if (r.component) {
-            await handleRoute(
-              {
-                path: routePath,
-                props: childProps,
-                script: r.script,
-                component: r.component,
-                meta,
-              },
-              renderLayout,
-              outputDir
-            );
-          } else if (r.children?.["/"]?.component) {
+          if (routeNode.component) {
+            await handleRoute({ ...routeNode, path: routePath, props: childProps, meta }, renderLayout);
+          } else if (routeNode.children?.["/"]?.component) {
             // If dynamic route has children with a default component
-            await handleRoute(
-              {
-                path: routePath,
-                props: childProps,
-                script: r.children["/"].script,
-                component: r.children["/"].component,
-                meta: r.children["/"].meta || meta, // Children's meta takes precedence
-              },
-              renderLayout,
-              outputDir
-            );
+            await handleRoute({ ...routeNode.children["/"], path: routePath, props: childProps, meta }, renderLayout);
             // Recursively build children of this dynamic item if they exist
-            if (r.children) {
-              await buildRoutes(r.children, routePath, childProps, renderLayout, outputDir);
+            if (routeNode.children) {
+              await buildRoutes(routeNode.children, renderLayout, routePath, childProps);
             }
           } else {
             console.warn(
@@ -83,53 +64,27 @@ export async function buildRoutes(routes, parentPath = "", props = {}, renderLay
           }
         }
       } catch (e) {
-        console.warn(`⚠️  Skipped dynamic route generation for ${joinPaths(parentPath, routeKey)}: ${e.message}`);
+        console.warn(`⚠️  Skipped dynamic route generation for ${currentRoute}: ${e.message}`);
       }
       continue; // Move to the next route key after handling dynamic list
     }
 
     // Handle static routes with a component
-    if (r.component) {
-      const routePath = joinPaths(parentPath, routeKey);
-      await handleRoute(
-        {
-          path: routePath,
-          props,
-          script: r.script,
-          component: r.component,
-          meta: r.meta,
-        },
-        renderLayout,
-        outputDir
-      );
+    if (routeNode.component) {
+      await handleRoute({ path: currentRoute, ...routeNode, props }, renderLayout);
       // Continue to children if they exist for this static route
-      if (r.children) {
-        await buildRoutes(r.children, routePath, { ...props }, renderLayout, outputDir);
+      if (routeNode.children) {
+        await buildRoutes(routeNode.children, renderLayout, currentRoute, { ...props });
       }
       continue;
     }
-
-    // Handle routes with only children (e.g., a folder route with no direct component, but an index component)
-    if (r.children) {
-      const routePath = joinPaths(parentPath, routeKey);
-      // Render the default child component ('/') for this path if it exists
-      if (r.children["/"]?.component) {
-        await handleRoute(
-          {
-            path: routePath,
-            props,
-            script: r.children["/"].script,
-            component: r.children["/"].component,
-            meta: r.children["/"].meta,
-          },
-          renderLayout,
-          outputDir
-        );
-      } else {
-        console.warn(`⚠️  Route at ${routePath} has children but no default component ('/')`);
-      }
-      // Recursively build the children
-      await buildRoutes(r.children, routePath, { ...props }, renderLayout, outputDir);
+    // Render the default child component ('/') for this path if it exists
+    if (routeNode.children["/"]?.component) {
+      await handleRoute({ path: currentRoute, ...routeNode.children["/"], props }, renderLayout);
+    } else if (routeNode.children) {
+      console.warn(`⚠️  Route at ${currentRoute} has children but no default component ('/')`);
     }
+    // Recursively build the children
+    await buildRoutes(routeNode.children, renderLayout, currentRoute, { ...props });
   }
 }