slicejs-cli 2.9.1 → 2.9.3

package/client.js

@@ -137,9 +137,15 @@ sliceClient
 const buildCommand = sliceClient.command("build")
   .description("Build Slice.js project for production")
   .action(async (options) => {
-    await runWithVersionCheck(async () => {
-      await build(options);
-    });
+    const prevEnv = process.env.NODE_ENV;
+    process.env.NODE_ENV = 'production';
+    try {
+      await runWithVersionCheck(async () => {
+        await build(options);
+      });
+    } finally {
+      process.env.NODE_ENV = prevEnv;
+    }
   });
 
 buildCommand
@@ -172,14 +178,22 @@ sliceClient
   .option("-p, --port <port>", "Port for development server", 3000)
   .option("-w, --watch", "Enable watch mode for file changes")
   .action(async (options) => {
-    await runWithVersionCheck(async () => {
-      await startServer({
-        mode: 'development',
-        port: parseInt(options.port),
-        watch: options.watch,
-        bundled: false
+    // Ensure the process.env.NODE_ENV reflects the requested mode for any
+    // code (builds, spawned processes, libraries) that reads it.
+    const prevEnv = process.env.NODE_ENV;
+    process.env.NODE_ENV = 'development';
+    try {
+      await runWithVersionCheck(async () => {
+        await startServer({
+          mode: 'development',
+          port: parseInt(options.port),
+          watch: options.watch,
+          bundled: false
+        });
       });
-    });
+    } finally {
+      process.env.NODE_ENV = prevEnv;
+    }
   });
 
 // START COMMAND - PRODUCTION MODE
@@ -189,14 +203,20 @@ sliceClient
   .option("-p, --port <port>", "Port for server", 3000)
   .option("-w, --watch", "Enable watch mode for file changes")
   .action(async (options) => {
-    await runWithVersionCheck(async () => {
-      await startServer({
-        mode: 'production',
-        port: parseInt(options.port),
-        watch: options.watch,
-        bundled: false
+    const prevEnv = process.env.NODE_ENV;
+    process.env.NODE_ENV = 'production';
+    try {
+      await runWithVersionCheck(async () => {
+        await startServer({
+          mode: 'production',
+          port: parseInt(options.port),
+          watch: options.watch,
+          bundled: false
+        });
       });
-    });
+    } finally {
+      process.env.NODE_ENV = prevEnv;
+    }
   });
 
 // COMPONENT COMMAND GROUP - For local component management

package/commands/startServer/startServer.js

@@ -94,12 +94,18 @@ function startNodeServer(port, mode) {
       args.push('--development');
     }
 
+    // Ensure the spawned server process receives NODE_ENV consistent with the
+    // requested mode. This guarantees code that only checks process.env.NODE_ENV
+    // (instead of CLI flags) will behave as expected.
+    const serverEnv = {
+      ...process.env,
+      PORT: port,
+      NODE_ENV: mode === 'production' ? 'production' : (process.env.NODE_ENV || 'development')
+    };
+
     const serverProcess = spawn('node', args, {
       stdio: ['inherit', 'pipe', 'pipe'],
-      env: {
-        ...process.env,
-        PORT: port
-      }
+      env: serverEnv
     });
 
     let serverStarted = false;

package/commands/utils/bundling/DependencyAnalyzer.js

@@ -3,7 +3,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
-import { getSrcPath, getComponentsJsPath, getProjectRoot } from '../PathHelper.js';
+import { getSrcPath, getComponentsJsPath, getProjectRoot, getConfigPath } from '../PathHelper.js';
 
 export default class DependencyAnalyzer {
   constructor(moduleUrl) {
@@ -64,11 +64,21 @@ export default class DependencyAnalyzer {
    */
   async loadComponentsConfig() {
     const componentsConfigPath = path.join(this.componentsPath, 'components.js');
+    const configPath = getConfigPath(this.moduleUrl);
+    let sliceConfig = {};
 
     if (!await fs.pathExists(componentsConfigPath)) {
       throw new Error('components.js not found');
     }
 
+    if (await fs.pathExists(configPath)) {
+      try {
+        sliceConfig = await fs.readJson(configPath);
+      } catch (error) {
+        console.warn('Warning: Could not read sliceConfig.json for component paths:', error.message);
+      }
+    }
+
     // Read and parse components.js
     const content = await fs.readFile(componentsConfigPath, 'utf-8');
 
@@ -87,13 +97,18 @@ export default class DependencyAnalyzer {
 
     // Process each category
     for (const [categoryName, componentList] of categoryMap) {
-      // Determine category type based on category name
-      let categoryType = 'Visual'; // default
+      const configCategory = sliceConfig?.paths?.components?.[categoryName];
+
+      // Determine category type based on config or category name
+      let categoryType = configCategory?.type || 'Visual';
       if (categoryName === 'Service') categoryType = 'Service';
       if (categoryName === 'AppComponents') categoryType = 'Visual'; // AppComponents are visual
 
-      // Find category path
-      const categoryPath = path.join(this.componentsPath, categoryName);
+      // Resolve category path from config if available
+      let categoryPath = path.join(this.componentsPath, categoryName);
+      if (configCategory?.path) {
+        categoryPath = getSrcPath(this.moduleUrl, configCategory.path);
+      }
 
       if (await fs.pathExists(categoryPath)) {
         const files = await fs.readdir(categoryPath);
@@ -330,6 +345,17 @@ export default class DependencyAnalyzer {
         return node;
       }
 
+      if (node.type === 'CallExpression') {
+        const calleeName = node.callee?.name || null;
+        if (calleeName && node.arguments?.length) {
+          const firstArg = node.arguments[0];
+          const resolvedObject = resolveObjectExpression(firstArg, scope);
+          if (resolvedObject) {
+            return resolvedObject;
+          }
+        }
+      }
+
       if (node.type === 'ObjectExpression') {
         const routesProp = node.properties.find(p => p.key?.name === 'routes');
         if (routesProp?.value) {
@@ -348,6 +374,10 @@ export default class DependencyAnalyzer {
             return init;
           }
 
+          if (init?.type === 'CallExpression') {
+            return resolveRoutesArray(init, binding.path.scope);
+          }
+
           if (init?.type === 'Identifier') {
             return resolveRoutesArray(init, binding.path.scope);
           }
@@ -562,8 +592,46 @@ export default class DependencyAnalyzer {
       return null;
     };
 
+    const addRouteConfigDependencies = (routesConfigNode, scope) => {
+      if (!routesConfigNode || routesConfigNode.type !== 'ObjectExpression') return;
+
+      const processObject = (node) => {
+        if (!node || node.type !== 'ObjectExpression') return;
+
+        const componentProp = node.properties.find(p => p.key?.name === 'component');
+        if (componentProp?.value) {
+          const componentName = resolveStringValue(componentProp.value, scope);
+          if (componentName) {
+            dependencies.add(componentName);
+          }
+        }
+
+        const itemsProp = node.properties.find(p => p.key?.name === 'items');
+        if (itemsProp?.value) {
+          const itemsNode = resolveRoutesArray(itemsProp.value, scope);
+          addMultiRouteDependencies(itemsNode, scope);
+        }
+
+        node.properties.forEach((prop) => {
+          const valueNode = prop.value;
+          if (valueNode?.type === 'ObjectExpression') {
+            processObject(valueNode);
+          }
+        });
+      };
+
+      processObject(routesConfigNode);
+    };
+
     const addMultiRouteDependencies = (routesArrayNode, scope) => {
-      if (!routesArrayNode || routesArrayNode.type !== 'ArrayExpression') return;
+      if (!routesArrayNode) return;
+
+      if (routesArrayNode.type === 'ObjectExpression') {
+        addRouteConfigDependencies(routesArrayNode, scope);
+        return;
+      }
+
+      if (routesArrayNode.type !== 'ArrayExpression') return;
 
       routesArrayNode.elements.forEach(routeElement => {
         if (!routeElement) return;
@@ -583,6 +651,12 @@ export default class DependencyAnalyzer {
               dependencies.add(componentName);
             }
           }
+
+          const itemsProp = routeObject.properties.find(p => p.key?.name === 'items');
+          if (itemsProp?.value) {
+            const itemsNode = resolveRoutesArray(itemsProp.value, scope);
+            addMultiRouteDependencies(itemsNode, scope);
+          }
         }
       });
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slicejs-cli",
-  "version": "2.9.1",
+  "version": "2.9.3",
   "description": "Command client for developing web applications with Slice.js framework",
   "main": "client.js",
   "bin": {
@@ -29,6 +29,8 @@
   "preferGlobal": false,
   "license": "ISC",
   "dependencies": {
+    "@babel/parser": "^7.28.5",
+    "@babel/traverse": "^7.28.5",
     "chalk": "^5.6.2",
     "chokidar": "^3.6.0",
     "clean-css": "^5.3.3",
@@ -39,8 +41,6 @@
     "inquirer": "^12.4.2",
     "ora": "^8.2.0",
     "slicejs-web-framework": "latest",
-    "terser": "^5.43.1",
-    "@babel/parser": "^7.28.5",
-    "@babel/traverse": "^7.28.5"
+    "terser": "^5.43.1"
   }
 }