@nitronjs/framework 0.2.26 → 0.3.0

package/lib/Auth/Auth.js

@@ -134,7 +134,7 @@ class Auth {
             return res.redirect("/");
         }
 
-        if (path.startsWith("/") || path.startsWith("http://") || path.startsWith("https://")) {
+        if (path.startsWith("/")) {
             return res.redirect(path);
         }
 
@@ -157,7 +157,7 @@ class Auth {
             return res.redirect("/");
         }
 
-        if (path.startsWith("/") || path.startsWith("http://") || path.startsWith("https://")) {
+        if (path.startsWith("/")) {
             return res.redirect(path);
         }
 

package/lib/Build/CssBuilder.js

@@ -10,14 +10,12 @@ import tailwindPostcss from "@tailwindcss/postcss";
  */
 class CssBuilder {
     #cache;
-    #isDev;
     #cssInput;
     #cssOutput;
     #hasTailwind = null;
 
-    constructor(cache, isDev, cssInput, cssOutput) {
+    constructor(cache, cssInput, cssOutput) {
         this.#cache = cache;
-        this.#isDev = isDev;
         this.#cssInput = cssInput;
         this.#cssOutput = cssOutput;
     }
@@ -27,7 +25,7 @@ class CssBuilder {
      * @param {boolean} viewsChanged - Whether views have changed (forces Tailwind rebuild).
      * @returns {Promise<number>} Number of CSS files processed.
      */
-    async build(viewsChanged) {
+    async build(viewsChanged, isDev = false) {
         if (!fs.existsSync(this.#cssInput)) {
             return 0;
         }
@@ -67,12 +65,12 @@ class CssBuilder {
         }
         const processor = hasTailwind ? this.#cache.tailwindProcessor : null;
 
-        await Promise.all(filesToProcess.map(filename => this.#processCss(filename, hasTailwind, processor)));
+        await Promise.all(filesToProcess.map(filename => this.#processCss(filename, hasTailwind, processor, isDev)));
 
         return filesToProcess.length;
     }
 
-    async #processCss(filename, hasTailwind, processor) {
+    async #processCss(filename, hasTailwind, processor, isDev) {
         const inputPath = path.join(this.#cssInput, filename);
         const outputPath = path.join(this.#cssOutput, filename);
 
@@ -92,7 +90,7 @@ class CssBuilder {
         const result = await processor.process(content, {
             from: inputPath,
             to: outputPath,
-            map: this.#isDev ? { inline: false } : false
+            map: isDev ? { inline: false } : false
         });
 
         await fs.promises.writeFile(outputPath, result.css);

package/lib/Build/EffectivePropUsage.js

@@ -0,0 +1,174 @@
+import path from "path";
+import { mergeUsageTrees, resolveComponentPath } from "./propUtils.js";
+
+/**
+ * Computes effective prop usage by merging child component prop usage
+ * back into parent components through JSX prop forwarding chains.
+ *
+ * Example: ParentComponent forwards data → ChildComponent.info
+ *   ChildComponent uses: { title, description }
+ *   ParentComponent effective data = { title, description }
+ *   → unused fields are stripped at the server→client boundary
+ */
+class EffectivePropUsage {
+    /**
+     * @param {Map<string, object|null>} propUsageMap - Basic prop usage per client component (from analyze()).
+     * @param {Map<string, {forwards: Array, imports: object}>} forwardMap - Forward info per component.
+     * @param {Set<string>} clientPaths - All client component absolute paths.
+     * @returns {Map<string, object|null>} Effective prop usage per component.
+     */
+    static compute(propUsageMap, forwardMap, clientPaths) {
+        const resolvedForwards = resolveForwards(forwardMap, clientPaths);
+        const { children, parents } = buildGraph(resolvedForwards);
+        const order = topologicalSort(clientPaths, children, parents);
+
+        const effectiveMap = new Map();
+
+        for (const [filePath, usage] of propUsageMap) {
+            effectiveMap.set(filePath, usage ? structuredClone(usage) : null);
+        }
+
+        for (const componentPath of order) {
+            const forwards = resolvedForwards.get(componentPath);
+            if (!forwards) continue;
+
+            let effective = effectiveMap.get(componentPath);
+            if (effective === null) continue;
+            if (!effective) effective = {};
+
+            for (const { parentProp, childPath, childProp } of forwards) {
+                const childEffective = effectiveMap.get(childPath);
+                let childPropUsage;
+
+                if (childEffective === null) {
+                    childPropUsage = true;
+                }
+                else if (childEffective && childProp in childEffective) {
+                    childPropUsage = childEffective[childProp];
+                }
+                else {
+                    continue;
+                }
+
+                if (effective[parentProp] === true) {
+                    // Basic usage was "whole" (likely from JSX forwarding itself).
+                    // Replace with child's actual usage — this is the core optimization.
+                    effective[parentProp] = childPropUsage;
+                }
+                else if (effective[parentProp] && typeof effective[parentProp] === "object") {
+                    effective[parentProp] = mergeUsageTrees(effective[parentProp], childPropUsage);
+                }
+                else {
+                    effective[parentProp] = childPropUsage;
+                }
+            }
+
+            effectiveMap.set(componentPath, effective);
+        }
+
+        return effectiveMap;
+    }
+}
+
+
+/**
+ * Resolves relative import paths in forwards to absolute file paths.
+ * Only keeps forwards to known client components.
+ */
+function resolveForwards(forwardMap, clientPaths) {
+    const resolved = new Map();
+
+    for (const [filePath, info] of forwardMap) {
+        if (!info?.forwards?.length) continue;
+
+        const dir = path.dirname(filePath);
+        const items = [];
+
+        for (const fwd of info.forwards) {
+            const childPath = resolveComponentPath(fwd.childImport, dir);
+
+            if (childPath && clientPaths.has(childPath)) {
+                items.push({
+                    parentProp: fwd.parentProp,
+                    childPath,
+                    childProp: fwd.childProp
+                });
+            }
+        }
+
+        if (items.length > 0) {
+            resolved.set(filePath, items);
+        }
+    }
+
+    return resolved;
+}
+
+/**
+ * Builds parent→children and child→parents adjacency lists from resolved forwards.
+ */
+function buildGraph(resolvedForwards) {
+    const children = new Map();
+    const parents = new Map();
+
+    for (const [parentPath, forwards] of resolvedForwards) {
+        for (const fwd of forwards) {
+            if (!children.has(parentPath)) children.set(parentPath, new Set());
+            children.get(parentPath).add(fwd.childPath);
+
+            if (!parents.has(fwd.childPath)) parents.set(fwd.childPath, new Set());
+            parents.get(fwd.childPath).add(parentPath);
+        }
+    }
+
+    return { children, parents };
+}
+
+/**
+ * Topological sort — processes leaf components (no forwards) first,
+ * then parents, so child effective usage is ready when parent is processed.
+ *
+ * Uses Kahn's algorithm on the reversed forwarding graph.
+ */
+function topologicalSort(allNodes, children, parents) {
+    const order = [];
+    const inDeg = new Map();
+
+    for (const node of allNodes) {
+        inDeg.set(node, children.get(node)?.size || 0);
+    }
+
+    const queue = [];
+
+    for (const [node, deg] of inDeg) {
+        if (deg === 0) queue.push(node);
+    }
+
+    const visited = new Set();
+    let qi = 0;
+
+    while (qi < queue.length) {
+        const node = queue[qi++];
+        order.push(node);
+        visited.add(node);
+
+        const parentSet = parents.get(node);
+        if (!parentSet) continue;
+
+        for (const parent of parentSet) {
+            const newDeg = inDeg.get(parent) - 1;
+            inDeg.set(parent, newDeg);
+
+            if (newDeg === 0) queue.push(parent);
+        }
+    }
+
+    // Nodes not visited = cycles. Add them at the end with basic usage.
+    for (const node of allNodes) {
+        if (!visited.has(node)) order.push(node);
+    }
+
+    return order;
+}
+
+export default EffectivePropUsage;

package/lib/Build/FactoryTransform.js

@@ -109,24 +109,4 @@ function transformFile(filePath) {
     return true;
 }
 
-/**
- * Transforms all built view files in a directory tree.
- */
-function transformDirectory(dir) {
-    let count = 0;
-
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const full = path.join(dir, entry.name);
-
-        if (entry.isDirectory()) {
-            count += transformDirectory(full);
-        }
-        else if (entry.name.endsWith(".js") && !entry.name.endsWith(".map")) {
-            if (transformFile(full)) count++;
-        }
-    }
-
-    return count;
-}
-
-export { transformFile, transformDirectory };
+export { transformFile };

package/lib/Build/FileAnalyzer.js

@@ -63,7 +63,7 @@ class FileAnalyzer {
 
         this.#validateGraph(graph, entries, importedBy);
 
-        return { entries, layouts, meta: graph };
+        return { entries, layouts, meta: graph, importedBy };
     }
 
     #findTsxFiles(dir, result = []) {
@@ -293,37 +293,6 @@ class FileAnalyzer {
         return resolved;
     }
 
-    findClientComponents(file, meta, seen, depth = 0) {
-        const result = new Set();
-
-        if (depth > MAX_DEPTH || seen.has(file)) {
-            return result;
-        }
-        seen.add(file);
-
-        const fileMeta = meta.get(file);
-        if (!fileMeta) {
-            return result;
-        }
-
-        if (fileMeta.isClient) {
-            result.add(file);
-        }
-
-        for (const importPath of fileMeta.imports) {
-            const resolvedPath = this.resolveImport(file, importPath);
-
-            if (meta.has(resolvedPath)) {
-                const childComponents = this.findClientComponents(resolvedPath, meta, seen, depth + 1);
-                for (const component of childComponents) {
-                    result.add(component);
-                }
-            }
-        }
-
-        return result;
-    }
-
     collectCss(file, meta, seen, depth = 0) {
         if (depth > MAX_DEPTH || seen.has(file)) {
             return new Set();
@@ -366,7 +335,7 @@ class FileAnalyzer {
                     throw this.#createError("Client Entry Imported", {
                         Entry: relativePath(filePath),
                         By: relativePath(importers[0]),
-                        Fix: "Use as island"
+                        Fix: "Add \"use client\" directive"
                     });
                 }
             }