slicejs-cli 2.9.0 → 2.9.2

package/commands/utils/bundling/BundleGenerator.js

@@ -467,7 +467,7 @@ export default class BundleGenerator {
         'critical',
         criticalFile.file
       );
-      this.bundles.critical.integrity = criticalIntegrity;
+      this.bundles.critical.integrity = `sha256:${criticalFile.hash}`;
       this.bundles.critical.hash = criticalFile.hash;
       files.push(criticalFile);
     }
@@ -483,13 +483,7 @@ export default class BundleGenerator {
         'route',
         routeIdentifier
       );
-      const routeIntegrity = this.computeBundleIntegrity(
-        bundle.components,
-        'route',
-        routeIdentifier,
-        this.routeToFileName(routeIdentifier),
-        routeFile.file
-      );
+      const routeIntegrity = `sha256:${routeFile.hash}`;
       const matchingBundle = Object.values(this.bundles.routes)
         .find((entry) => entry.file === routeFile.file);
       if (matchingBundle) {
@@ -540,7 +534,11 @@ export default class BundleGenerator {
       return bundleContent;
     }
 
-    const result = await terserMinify(bundleContent, {
+    const options = {
+      parse: {
+        ecma: 2022
+      },
+      ecma: 2022,
       compress: this.options.minify ? {
         drop_console: false,
         drop_debugger: true,
@@ -552,12 +550,39 @@ export default class BundleGenerator {
       keep_fnames: true,
       keep_classnames: true,
       format: {
-        comments: false
+        comments: false,
+        ecma: 2022
       }
-    });
+    };
+
+    let result;
+    try {
+      result = await terserMinify(bundleContent, options);
+    } catch (error) {
+      const tmpDir = path.resolve(process.cwd(), '.tmp');
+      const safeName = fileName.replace(/[^a-zA-Z0-9_.-]/g, '_');
+      const tmpPath = path.join(tmpDir, `terser-fail-${safeName}`);
+      try {
+        await fs.ensureDir(tmpDir);
+        await fs.writeFile(tmpPath, bundleContent, 'utf-8');
+      } catch (writeError) {
+        console.warn(`Warning: Failed to write ${tmpPath}:`, writeError.message);
+      }
+      const message = error?.message ? `${error.message}.` : 'Unknown Terser error.';
+      throw new Error(`Terser failed for ${fileName}: ${message} Saved bundle to ${tmpPath}`);
+    }
 
     if (result.error) {
-      throw new Error(`Terser failed for ${fileName}: ${result.error.message}`);
+      const tmpDir = path.resolve(process.cwd(), '.tmp');
+      const safeName = fileName.replace(/[^a-zA-Z0-9_.-]/g, '_');
+      const tmpPath = path.join(tmpDir, `terser-fail-${safeName}`);
+      try {
+        await fs.ensureDir(tmpDir);
+        await fs.writeFile(tmpPath, bundleContent, 'utf-8');
+      } catch (writeError) {
+        console.warn(`Warning: Failed to write ${tmpPath}:`, writeError.message);
+      }
+      throw new Error(`Terser failed for ${fileName}: ${result.error.message}. Saved bundle to ${tmpPath}`);
     }
 
     return result.code || bundleContent;
@@ -737,11 +762,30 @@ export default class BundleGenerator {
     // Remove imports (components will already be available)
     code = code.replace(/import\s+.*?from\s+['"].*?['"];?\s*/g, '');
 
+    // Guard customElements.define to avoid duplicate registrations
+    code = code.replace(
+      /customElements\.define\(([^)]+)\);?/g,
+      (match, args) => {
+        const firstArg = args.split(',')[0]?.trim() || '';
+        if (!/^['"][^'"]+['"]$/.test(firstArg)) {
+          return match;
+        }
+        return `if (!customElements.get(${firstArg})) { customElements.define(${args}); }`;
+      }
+    );
+
     // Make sure the class is available globally for bundle evaluation
     // Preserve original customElements.define if it exists
     if (code.includes('customElements.define')) {
-      // Add global assignment before customElements.define
-      code = code.replace(/customElements\.define\([^;]+\);?\s*$/, `window.${componentName} = ${componentName};\n$&`);
+      // Add global assignment before guarded or direct customElements.define
+      const globalAssignment = `window.${componentName} = ${componentName};\n`;
+      const guardedDefineRegex = /if\s*\(\s*!\s*customElements\.get\([^)]*\)\s*\)\s*\{\s*customElements\.define\([^;]+\);?\s*\}\s*$/;
+      const directDefineRegex = /customElements\.define\([^;]+\);?\s*$/;
+      if (guardedDefineRegex.test(code)) {
+        code = code.replace(guardedDefineRegex, `${globalAssignment}$&`);
+      } else {
+        code = code.replace(directDefineRegex, `${globalAssignment}$&`);
+      }
     } else {
       // If no customElements.define found, just assign to global
       code += `\nwindow.${componentName} = ${componentName};`;
@@ -1072,7 +1116,7 @@ if (window.slice && window.slice.controller) {
     await fs.writeFile(filePath, finalContent, 'utf-8');
 
     const hash = crypto.createHash('sha256').update(finalContent).digest('hex');
-    const integrity = this.computeBundleIntegrity(components, 'framework', null, 'framework', fileName);
+    const integrity = `sha256:${hash}`;
 
     return {
       name: 'framework',

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.0",
+  "version": "2.9.2",
   "description": "Command client for developing web applications with Slice.js framework",
   "main": "client.js",
   "bin": {