@stati/core 1.9.0 → 1.10.0

package/dist/core/utils/navigation-helpers.js

@@ -0,0 +1,219 @@
+/**
+ * Navigation helper utilities for template context.
+ * Provides methods for querying and traversing the navigation tree.
+ */
+/**
+ * Finds a navigation node by its path or URL.
+ *
+ * @param tree - Navigation tree to search
+ * @param path - Path or URL to find
+ * @returns The found node or undefined
+ */
+export function findNode(tree, path) {
+    for (const node of tree) {
+        // Check current node
+        if (node.path === path || node.url === path) {
+            return node;
+        }
+        // Recursively search children
+        if (node.children && node.children.length > 0) {
+            const found = findNode(node.children, path);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Gets the children of a specific navigation node by path.
+ *
+ * @param tree - Navigation tree to search
+ * @param path - Path of the parent node
+ * @returns Array of child nodes or empty array if not found or no children
+ */
+export function getChildren(tree, path) {
+    const node = findNode(tree, path);
+    return node?.children || [];
+}
+/**
+ * Gets the parent node of a specific path.
+ *
+ * @param tree - Navigation tree to search
+ * @param path - Path to find parent for
+ * @returns The parent node or undefined
+ */
+export function getParent(tree, path) {
+    return findParentNode(tree, path, null);
+}
+/**
+ * Helper function to find parent node recursively.
+ *
+ * @param nodes - Current nodes to search
+ * @param targetPath - Path we're looking for
+ * @param parent - Current parent node
+ * @returns The parent node or undefined
+ */
+function findParentNode(nodes, targetPath, parent) {
+    for (const node of nodes) {
+        // Check if this node is the target
+        if (node.path === targetPath || node.url === targetPath) {
+            return parent || undefined;
+        }
+        // Recursively search children with this node as parent
+        if (node.children && node.children.length > 0) {
+            const found = findParentNode(node.children, targetPath, node);
+            if (found !== undefined) {
+                return found;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Gets the siblings of a specific path (nodes at the same level).
+ *
+ * @param tree - Navigation tree to search
+ * @param path - Path to find siblings for
+ * @param includeSelf - Whether to include the node itself in the results
+ * @returns Array of sibling nodes or empty array
+ */
+export function getSiblings(tree, path, includeSelf = false) {
+    const parent = getParent(tree, path);
+    // If no parent, check if the node is at root level
+    if (!parent) {
+        // Node might be at root level
+        const isAtRoot = tree.some((node) => node.path === path || node.url === path);
+        if (isAtRoot) {
+            return includeSelf ? tree : tree.filter((node) => node.path !== path && node.url !== path);
+        }
+        return [];
+    }
+    const siblings = parent.children || [];
+    return includeSelf
+        ? siblings
+        : siblings.filter((node) => node.path !== path && node.url !== path);
+}
+/**
+ * Gets a subtree starting from a specific path.
+ *
+ * @param tree - Navigation tree to search
+ * @param path - Root path for the subtree
+ * @returns The subtree as an array (single node with its children) or empty array
+ */
+export function getSubtree(tree, path) {
+    const node = findNode(tree, path);
+    return node ? [node] : [];
+}
+/**
+ * Gets the breadcrumb trail from root to a specific path.
+ *
+ * @param tree - Navigation tree to search
+ * @param path - Path to get breadcrumbs for
+ * @returns Array of nodes from root to the target path
+ */
+export function getBreadcrumbs(tree, path) {
+    const trail = [];
+    findBreadcrumbTrail(tree, path, trail);
+    return trail;
+}
+/**
+ * Helper function to build breadcrumb trail recursively.
+ *
+ * @param nodes - Current nodes to search
+ * @param targetPath - Path we're looking for
+ * @param trail - Current breadcrumb trail
+ * @returns True if the target was found in this branch
+ */
+function findBreadcrumbTrail(nodes, targetPath, trail) {
+    for (const node of nodes) {
+        // Add current node to trail
+        trail.push(node);
+        // Check if this is the target
+        if (node.path === targetPath || node.url === targetPath) {
+            return true;
+        }
+        // Check children
+        if (node.children && node.children.length > 0) {
+            if (findBreadcrumbTrail(node.children, targetPath, trail)) {
+                return true;
+            }
+        }
+        // This branch didn't contain the target, remove this node from trail
+        trail.pop();
+    }
+    return false;
+}
+/**
+ * Finds the current page's navigation node.
+ *
+ * @param tree - Navigation tree to search
+ * @param currentPage - Current page model
+ * @returns The navigation node for the current page or undefined
+ */
+export function getCurrentNode(tree, currentPage) {
+    return findNode(tree, currentPage.url);
+}
+/**
+ * Creates a navigation helpers object for template context.
+ *
+ * @param tree - The full navigation tree
+ * @param currentPage - The current page being rendered
+ * @returns Object with navigation helper methods
+ */
+export function createNavigationHelpers(tree, currentPage) {
+    return {
+        /**
+         * The full navigation tree.
+         * Use stati.nav.tree to access the global navigation.
+         */
+        tree,
+        /**
+         * Gets the full navigation tree.
+         * @returns The complete navigation tree
+         */
+        getTree: () => tree,
+        /**
+         * Finds a navigation node by path or URL.
+         * @param path - The path or URL to find
+         * @returns The found node or undefined
+         */
+        findNode: (path) => findNode(tree, path),
+        /**
+         * Gets the children of a navigation node.
+         * @param path - The path of the parent node
+         * @returns Array of child navigation nodes
+         */
+        getChildren: (path) => getChildren(tree, path),
+        /**
+         * Gets the parent of a navigation node.
+         * @param path - The path to find the parent for (defaults to current page)
+         * @returns The parent node or undefined
+         */
+        getParent: (path) => getParent(tree, path || currentPage.url),
+        /**
+         * Gets the siblings of a navigation node.
+         * @param path - The path to find siblings for (defaults to current page)
+         * @param includeSelf - Whether to include the node itself
+         * @returns Array of sibling nodes
+         */
+        getSiblings: (path, includeSelf = false) => getSiblings(tree, path || currentPage.url, includeSelf),
+        /**
+         * Gets a subtree starting from a specific path.
+         * @param path - The root path for the subtree
+         * @returns Array containing the subtree
+         */
+        getSubtree: (path) => getSubtree(tree, path),
+        /**
+         * Gets the breadcrumb trail for a path.
+         * @param path - The path to get breadcrumbs for (defaults to current page)
+         * @returns Array of nodes from root to the target
+         */
+        getBreadcrumbs: (path) => getBreadcrumbs(tree, path || currentPage.url),
+        /**
+         * Gets the current page's navigation node.
+         * @returns The navigation node for the current page or undefined
+         */
+        getCurrentNode: () => getCurrentNode(tree, currentPage),
+    };
+}

package/dist/core/utils/server.d.ts

@@ -12,7 +12,7 @@ export interface PrettyUrlResult {
  * This handles common patterns like:
  * - /path/ -> /path/index.html
  * - /path/ -> /path.html (if no index.html exists)
- * - /path -> /path.html (when original path is not found)
+ * - /path -> /path.html (when original path is not found and has no extension)
  *
  * @param outDir The output directory to serve files from
  * @param requestPath The requested URL path

package/dist/core/utils/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/core/utils/server.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,sCAAsC;IACtC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,iCAAiC;IACjC,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,eAAe,CAAC,CA+C1B"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/core/utils/server.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,sCAAsC;IACtC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,iCAAiC;IACjC,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,eAAe,CAAC,CA2D1B"}

package/dist/core/utils/server.js

@@ -5,7 +5,7 @@ import { stat } from 'fs/promises';
  * This handles common patterns like:
  * - /path/ -> /path/index.html
  * - /path/ -> /path.html (if no index.html exists)
- * - /path -> /path.html (when original path is not found)
+ * - /path -> /path.html (when original path is not found and has no extension)
  *
  * @param outDir The output directory to serve files from
  * @param requestPath The requested URL path
@@ -55,6 +55,19 @@ export async function resolvePrettyUrl(outDir, requestPath, originalFilePath) {
                 // Continue to not found
             }
         }
+        else if (!requestPath.includes('.')) {
+            // For requests without trailing slash and without extension, try .html
+            const htmlPath = join(outDir, `${requestPath}.html`);
+            try {
+                const stats = await stat(htmlPath);
+                if (stats.isFile()) {
+                    return { filePath: htmlPath, found: true };
+                }
+            }
+            catch {
+                // Continue to not found
+            }
+        }
         // No fallback worked
         return { filePath: null, found: false };
     }

package/dist/core/utils/tailwind-inventory.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Tailwind Class Inventory Management
+ *
+ * Tracks Tailwind classes used in templates (especially dynamic ones) and generates
+ * an HTML file that Tailwind can scan during its build process. This ensures that
+ * dynamically constructed classes (e.g., `from-${color}-50`) are included in the
+ * final CSS output.
+ */
+/**
+ * Detects if Tailwind CSS is being used in the project by checking for:
+ * 1. tailwind.config.js or tailwind.config.ts
+ * 2. tailwindcss in package.json dependencies
+ *
+ * Results are cached to avoid repeated file system checks.
+ *
+ * @param projectRoot - Root directory of the project (defaults to current working directory)
+ * @returns True if Tailwind is detected, false otherwise
+ */
+export declare function isTailwindUsed(projectRoot?: string): Promise<boolean>;
+/**
+ * Resets the Tailwind detection cache.
+ * Useful for testing or when project dependencies change.
+ */
+export declare function resetTailwindDetection(): void;
+/**
+ * Loads classes from a previous inventory file and seeds the current inventory.
+ * This is useful to preserve dynamic classes from previous builds, especially
+ * during dev server startup where Tailwind may scan before templates are rendered.
+ *
+ * @param cacheDir - Directory where the inventory file is located (typically .stati/)
+ * @returns Number of classes loaded from the previous inventory
+ */
+export declare function loadPreviousInventory(cacheDir: string): Promise<number>;
+/**
+ * Tracks a Tailwind class in the inventory.
+ * Only tracks if inventory tracking is enabled.
+ *
+ * @param className - The class name to track
+ */
+export declare function trackTailwindClass(className: string): void;
+/**
+ * Enables inventory tracking for the current build/dev session.
+ * Should be called at the start of build or dev server.
+ */
+export declare function enableInventoryTracking(): void;
+/**
+ * Disables inventory tracking.
+ * Should be called after build completes or when stopping dev server.
+ */
+export declare function disableInventoryTracking(): void;
+/**
+ * Clears the inventory.
+ * Should be called at the start of each full build to ensure fresh tracking.
+ */
+export declare function clearInventory(): void;
+/**
+ * Gets the current inventory as an array.
+ * Useful for testing and debugging.
+ *
+ * @returns Array of tracked class names
+ */
+export declare function getInventory(): string[];
+/**
+ * Gets the count of tracked classes.
+ *
+ * @returns Number of classes in the inventory
+ */
+export declare function getInventorySize(): number;
+/**
+ * Checks if inventory tracking is currently enabled.
+ *
+ * @returns True if tracking is enabled
+ */
+export declare function isTrackingEnabled(): boolean;
+/**
+ * Writes the Tailwind class inventory to an HTML file that Tailwind can scan.
+ *
+ * The generated file contains all tracked classes in a hidden div.
+ * This file should be added to Tailwind's content configuration.
+ *
+ * @param cacheDir - Directory where the inventory file should be written (typically .stati/)
+ * @returns Path to the generated inventory file
+ *
+ * @example
+ * ```typescript
+ * const inventoryPath = await writeTailwindClassInventory('/path/to/project/.stati');
+ * // File written to: /path/to/project/.stati/tailwind-classes.html
+ * ```
+ */
+export declare function writeTailwindClassInventory(cacheDir: string): Promise<string>;
+//# sourceMappingURL=tailwind-inventory.d.ts.map

package/dist/core/utils/tailwind-inventory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tailwind-inventory.d.ts","sourceRoot":"","sources":["../../../src/core/utils/tailwind-inventory.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAsBH;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAAC,WAAW,GAAE,MAAsB,GAAG,OAAO,CAAC,OAAO,CAAC,CA4C1F;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAkC7E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAI1D;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAE9C;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAErC;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,IAAI,MAAM,EAAE,CAEvC;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,2BAA2B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA6CnF"}

package/dist/core/utils/tailwind-inventory.js

@@ -0,0 +1,228 @@
+/**
+ * Tailwind Class Inventory Management
+ *
+ * Tracks Tailwind classes used in templates (especially dynamic ones) and generates
+ * an HTML file that Tailwind can scan during its build process. This ensures that
+ * dynamically constructed classes (e.g., `from-${color}-50`) are included in the
+ * final CSS output.
+ */
+import { writeFile, ensureDir, pathExists, readFile } from './fs.js';
+import { join } from 'path';
+/**
+ * Module-level Set to track Tailwind classes across template renders.
+ * Cleared at the start of each full build.
+ */
+const tailwindClassInventory = new Set();
+/**
+ * Flag to track if inventory tracking is enabled.
+ * Only enabled during build/dev, not during production rendering.
+ */
+let inventoryTrackingEnabled = false;
+/**
+ * Cached result of Tailwind detection to avoid repeated file system checks.
+ */
+let tailwindDetected = null;
+/**
+ * Detects if Tailwind CSS is being used in the project by checking for:
+ * 1. tailwind.config.js or tailwind.config.ts
+ * 2. tailwindcss in package.json dependencies
+ *
+ * Results are cached to avoid repeated file system checks.
+ *
+ * @param projectRoot - Root directory of the project (defaults to current working directory)
+ * @returns True if Tailwind is detected, false otherwise
+ */
+export async function isTailwindUsed(projectRoot = process.cwd()) {
+    // Return cached result if available
+    if (tailwindDetected !== null) {
+        return tailwindDetected;
+    }
+    // Check for tailwind.config.js or tailwind.config.ts
+    const configExists = (await pathExists(join(projectRoot, 'tailwind.config.js'))) ||
+        (await pathExists(join(projectRoot, 'tailwind.config.ts'))) ||
+        (await pathExists(join(projectRoot, 'tailwind.config.mjs'))) ||
+        (await pathExists(join(projectRoot, 'tailwind.config.cjs')));
+    if (configExists) {
+        tailwindDetected = true;
+        return true;
+    }
+    // Check package.json for tailwindcss dependency
+    try {
+        const packageJsonPath = join(projectRoot, 'package.json');
+        if (await pathExists(packageJsonPath)) {
+            const content = await readFile(packageJsonPath, 'utf-8');
+            if (!content) {
+                return false;
+            }
+            const packageJson = JSON.parse(content);
+            const deps = {
+                ...packageJson.dependencies,
+                ...packageJson.devDependencies,
+            };
+            if (deps.tailwindcss) {
+                tailwindDetected = true;
+                return true;
+            }
+        }
+    }
+    catch {
+        // Ignore errors reading package.json
+    }
+    tailwindDetected = false;
+    return false;
+}
+/**
+ * Resets the Tailwind detection cache.
+ * Useful for testing or when project dependencies change.
+ */
+export function resetTailwindDetection() {
+    tailwindDetected = null;
+}
+/**
+ * Loads classes from a previous inventory file and seeds the current inventory.
+ * This is useful to preserve dynamic classes from previous builds, especially
+ * during dev server startup where Tailwind may scan before templates are rendered.
+ *
+ * @param cacheDir - Directory where the inventory file is located (typically .stati/)
+ * @returns Number of classes loaded from the previous inventory
+ */
+export async function loadPreviousInventory(cacheDir) {
+    const inventoryPath = join(cacheDir, 'tailwind-classes.html');
+    if (!(await pathExists(inventoryPath))) {
+        return 0;
+    }
+    try {
+        const content = await readFile(inventoryPath, 'utf-8');
+        if (!content) {
+            return 0;
+        }
+        // Extract classes from the div's class attribute
+        // Looking for: <div class="class1 class2 class3"></div>
+        const classMatch = content.match(/<div class="([^"]+)"><\/div>/);
+        if (!classMatch || !classMatch[1]) {
+            return 0;
+        }
+        const classes = classMatch[1].split(/\s+/).filter(Boolean);
+        // Track each class from the previous inventory
+        for (const className of classes) {
+            trackTailwindClass(className);
+        }
+        return classes.length;
+    }
+    catch {
+        // If we can't read or parse the file, just return 0
+        return 0;
+    }
+}
+/**
+ * Tracks a Tailwind class in the inventory.
+ * Only tracks if inventory tracking is enabled.
+ *
+ * @param className - The class name to track
+ */
+export function trackTailwindClass(className) {
+    if (inventoryTrackingEnabled && className) {
+        tailwindClassInventory.add(className);
+    }
+}
+/**
+ * Enables inventory tracking for the current build/dev session.
+ * Should be called at the start of build or dev server.
+ */
+export function enableInventoryTracking() {
+    inventoryTrackingEnabled = true;
+}
+/**
+ * Disables inventory tracking.
+ * Should be called after build completes or when stopping dev server.
+ */
+export function disableInventoryTracking() {
+    inventoryTrackingEnabled = false;
+}
+/**
+ * Clears the inventory.
+ * Should be called at the start of each full build to ensure fresh tracking.
+ */
+export function clearInventory() {
+    tailwindClassInventory.clear();
+}
+/**
+ * Gets the current inventory as an array.
+ * Useful for testing and debugging.
+ *
+ * @returns Array of tracked class names
+ */
+export function getInventory() {
+    return Array.from(tailwindClassInventory).sort();
+}
+/**
+ * Gets the count of tracked classes.
+ *
+ * @returns Number of classes in the inventory
+ */
+export function getInventorySize() {
+    return tailwindClassInventory.size;
+}
+/**
+ * Checks if inventory tracking is currently enabled.
+ *
+ * @returns True if tracking is enabled
+ */
+export function isTrackingEnabled() {
+    return inventoryTrackingEnabled;
+}
+/**
+ * Writes the Tailwind class inventory to an HTML file that Tailwind can scan.
+ *
+ * The generated file contains all tracked classes in a hidden div.
+ * This file should be added to Tailwind's content configuration.
+ *
+ * @param cacheDir - Directory where the inventory file should be written (typically .stati/)
+ * @returns Path to the generated inventory file
+ *
+ * @example
+ * ```typescript
+ * const inventoryPath = await writeTailwindClassInventory('/path/to/project/.stati');
+ * // File written to: /path/to/project/.stati/tailwind-classes.html
+ * ```
+ */
+export async function writeTailwindClassInventory(cacheDir) {
+    await ensureDir(cacheDir);
+    const inventoryPath = join(cacheDir, 'tailwind-classes.html');
+    const classes = getInventory();
+    // Generate HTML with all tracked classes
+    // Using hidden div so it's scanned by Tailwind but not rendered
+    const html = `<!--
+  Auto-generated by Stati - DO NOT EDIT
+
+  This file contains dynamically-generated Tailwind classes extracted from your templates.
+  It ensures that Tailwind's JIT compiler generates CSS for classes built with template
+  variables (e.g., from-\${color}-50).
+
+  Add this file to your tailwind.config.js content array:
+  content: [
+    './site/**/*.{md,eta,html}',
+    './.stati/tailwind-classes.html'
+  ]
+
+  Generated: ${new Date().toISOString()}
+  Classes tracked: ${classes.length}
+-->
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>Stati Tailwind Class Inventory</title>
+</head>
+<body>
+  <div class="hidden">
+    ${classes.length > 0
+        ? `<div class="${classes.join(' ')}"></div>`
+        : '<!-- No dynamic classes tracked yet -->'}
+  </div>
+</body>
+</html>
+`;
+    await writeFile(inventoryPath, html, 'utf-8');
+    return inventoryPath;
+}

package/dist/core/utils/template-utils.d.ts

@@ -6,6 +6,9 @@ type PropValueArg = string | number | boolean | null | undefined | Record<string
  * Builds a property value from various inputs, similar to classnames but for any property.
  * Accepts strings, arrays, and objects. Filters out falsy values.
  *
+ * Also tracks Tailwind classes for the class inventory when inventory tracking is enabled.
+ * This ensures dynamically-generated Tailwind classes are included in the CSS build.
+ *
  * @param args - Values to combine
  * @returns Combined property value string
  *

package/dist/core/utils/template-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template-utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/template-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,KAAK,YAAY,GACb,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,GACT,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAC5D,YAAY,EAAE,CAAC;AAEnB;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,GAAG,IAAI,EAAE,YAAY,EAAE,GAAG,MAAM,CAwBzD"}
+{"version":3,"file":"template-utils.d.ts","sourceRoot":"","sources":["../../../src/core/utils/template-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,KAAK,YAAY,GACb,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,GACT,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,GAC5D,YAAY,EAAE,CAAC;AAEnB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,GAAG,IAAI,EAAE,YAAY,EAAE,GAAG,MAAM,CA8CzD"}

package/dist/core/utils/template-utils.js

@@ -1,10 +1,14 @@
 /**
  * Utility functions for Eta templates
  */
+import { trackTailwindClass } from './tailwind-inventory.js';
 /**
  * Builds a property value from various inputs, similar to classnames but for any property.
  * Accepts strings, arrays, and objects. Filters out falsy values.
  *
+ * Also tracks Tailwind classes for the class inventory when inventory tracking is enabled.
+ * This ensures dynamically-generated Tailwind classes are included in the CSS build.
+ *
  * @param args - Values to combine
  * @returns Combined property value string
  *
@@ -20,17 +24,37 @@ export function propValue(...args) {
         if (!arg)
             continue;
         if (typeof arg === 'string' || typeof arg === 'number') {
-            classes.push(String(arg));
+            const classStr = String(arg);
+            classes.push(classStr);
+            // Track ALL classes for Tailwind inventory
+            // Split space-separated classes and track each one individually
+            const individualClasses = classStr.split(/\s+/).filter(Boolean);
+            for (const cls of individualClasses) {
+                trackTailwindClass(cls);
+            }
         }
         else if (Array.isArray(arg)) {
-            classes.push(...arg
+            const arrayClasses = arg
                 .filter((item) => item && (typeof item === 'string' || typeof item === 'number'))
-                .map(String));
+                .map(String);
+            classes.push(...arrayClasses);
+            // Track each class for Tailwind inventory
+            for (const classStr of arrayClasses) {
+                const individualClasses = classStr.split(/\s+/).filter(Boolean);
+                for (const cls of individualClasses) {
+                    trackTailwindClass(cls);
+                }
+            }
         }
         else if (typeof arg === 'object') {
             for (const [key, value] of Object.entries(arg)) {
                 if (value) {
                     classes.push(key);
+                    // Track for Tailwind inventory
+                    const individualClasses = key.split(/\s+/).filter(Boolean);
+                    for (const cls of individualClasses) {
+                        trackTailwindClass(cls);
+                    }
                 }
             }
         }