slicejs-cli 3.3.0 → 3.4.1

package/commands/startServer/watchServer.js

@@ -1,79 +1,79 @@
-import chokidar from 'chokidar';
-import chalk from 'chalk';
-import Print from '../Print.js';
-
-/**
- * Configura el watcher para archivos del proyecto
- * @param {ChildProcess} serverProcess - Proceso del servidor
- * @returns {FSWatcher} - Watcher de chokidar
- */
-export default function setupWatcher(serverProcess, onRestart) {
-    Print.info('Watch mode enabled - monitoring file changes...');
-    Print.newLine();
-
-    const watcher = chokidar.watch(['src/**/*', 'api/**/*'], {
-        ignored: [
-            /(^|[\/\\])\../,  // archivos ocultos
-            '**/node_modules/**',
-            '**/dist/**',
-            '**/bundles/**',
-            '**/*.log'
-        ],
-        persistent: true,
-        ignoreInitial: true,
-        awaitWriteFinish: {
-            stabilityThreshold: 100,
-            pollInterval: 50
-        }
-    });
-
-    let reloadTimeout;
-
-    watcher
-        .on('change', (path) => {
-            // Debounce para evitar múltiples reloads
-            clearTimeout(reloadTimeout);
-            reloadTimeout = setTimeout(() => {
-                if(onRestart) {
-                    console.log(chalk.yellow('🔄 Changes detected, restarting server...'));
-                    onRestart(path);
-                } else {
-                    console.log(chalk.yellow('🔄 Changes detected, server will reload automatically... (No handler)'));
-                }
-            }, 500);
-        })
-        .on('add', (path) => {
-             // console.log(chalk.green(`➕ New file added: ${path}`));
-             clearTimeout(reloadTimeout);
-             reloadTimeout = setTimeout(() => {
-                 if (onRestart) onRestart(path);
-             }, 500);
-        })
-        .on('unlink', (path) => {
-             // console.log(chalk.red(`➖ File removed: ${path}`));
-             clearTimeout(reloadTimeout);
-             reloadTimeout = setTimeout(() => {
-                 if (onRestart) onRestart(path);
-             }, 500);
-        })
-        .on('error', (error) => {
-            Print.error(`Watcher error: ${error.message}`);
-        })
-        .on('ready', () => {
-            console.log(chalk.gray('👀 Watching for file changes...'));
-            Print.newLine();
-        });
-
-    return watcher;
-}
-
-/**
- * Detiene el watcher de forma segura
- * @param {FSWatcher} watcher - Watcher a detener
- */
-export function stopWatcher(watcher) {
-    if (watcher) {
-        watcher.close();
-        console.log(chalk.gray('Watch mode stopped'));
-    }
-}
+import chokidar from 'chokidar';
+import chalk from 'chalk';
+import Print from '../Print.js';
+
+/**
+ * Configures the watcher for project files
+ * @param {ChildProcess} serverProcess - Server process
+ * @returns {FSWatcher} - Chokidar watcher
+ */
+export default function setupWatcher(serverProcess, onRestart) {
+    Print.info('Watch mode enabled - monitoring file changes...');
+    Print.newLine();
+
+    const watcher = chokidar.watch(['src/**/*', 'api/**/*'], {
+        ignored: [
+            /(^|[\/\\])\../,  // hidden files
+            '**/node_modules/**',
+            '**/dist/**',
+            '**/bundles/**',
+            '**/*.log'
+        ],
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 100,
+            pollInterval: 50
+        }
+    });
+
+    let reloadTimeout;
+
+    watcher
+        .on('change', (path) => {
+            // Debounce to avoid multiple reloads
+            clearTimeout(reloadTimeout);
+            reloadTimeout = setTimeout(() => {
+                if(onRestart) {
+                    console.log(chalk.yellow('🔄 Changes detected, restarting server...'));
+                    onRestart(path);
+                } else {
+                    console.log(chalk.yellow('🔄 Changes detected, server will reload automatically... (No handler)'));
+                }
+            }, 500);
+        })
+        .on('add', (path) => {
+             // console.log(chalk.green(`➕ New file added: ${path}`));
+             clearTimeout(reloadTimeout);
+             reloadTimeout = setTimeout(() => {
+                 if (onRestart) onRestart(path);
+             }, 500);
+        })
+        .on('unlink', (path) => {
+             // console.log(chalk.red(`➖ File removed: ${path}`));
+             clearTimeout(reloadTimeout);
+             reloadTimeout = setTimeout(() => {
+                 if (onRestart) onRestart(path);
+             }, 500);
+        })
+        .on('error', (error) => {
+            Print.error(`Watcher error: ${error.message}`);
+        })
+        .on('ready', () => {
+            console.log(chalk.gray('👀 Watching for file changes...'));
+            Print.newLine();
+        });
+
+    return watcher;
+}
+
+/**
+ * Stops the watcher safely
+ * @param {FSWatcher} watcher - Watcher to stop
+ */
+export function stopWatcher(watcher) {
+    if (watcher) {
+        watcher.close();
+        console.log(chalk.gray('Watch mode stopped'));
+    }
+}

package/commands/types/types.js

@@ -4,6 +4,7 @@ import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
 
 import Print from '../Print.js';
+import { getConfigPath, getComponentsJsPath, joinRoot } from '../utils/PathHelper.js';
 
 const TYPE_MAP = {
   string: 'string',
@@ -114,22 +115,29 @@ const sortKeys = (obj) => {
     }, {});
 };
 
-const parseComponentsRegistry = (content) => {
+const parseComponentsRegistry = (content, filePath) => {
   const match = content.match(/const components = ({[\s\S]*?});/);
   if (!match) {
-    throw new Error('Invalid components.js format. Expected: const components = { ... };');
+    throw new Error(`Invalid format in ${filePath}. Expected: const components = { ... };`);
+  }
+  try {
+    return JSON.parse(match[1]);
+  } catch (parseError) {
+    throw new Error(`Failed to parse components registry in ${filePath}: ${parseError.message}`);
   }
-  return JSON.parse(match[1]);
 };
 
-const extractStaticPropsFromSource = (source) => {
+const extractStaticPropsFromSource = (source, filePath) => {
   let ast;
   try {
     ast = parse(source, {
       sourceType: 'module',
       plugins: ['classProperties']
     });
-  } catch {
+  } catch (parseError) {
+    const sourceDesc = filePath || 'unknown file';
+    const loc = parseError.loc ? ` at line ${parseError.loc.line}, column ${parseError.loc.column}` : '';
+    Print.warning(`Parse error in ${sourceDesc}${loc}: ${parseError.message}`);
     return null;
   }
 
@@ -194,7 +202,7 @@ const DEFAULT_EDITOR_EXCLUDE = ['node_modules', 'dist', 'src/libs/**', 'tests/**
 const NOISY_INCLUDE_PATTERNS = new Set(['src/**/*.js', 'api/**/*.js', 'tests/**/*.js']);
 
 const readPublicFolderExcludes = async (projectRoot) => {
-  const configPath = path.join(projectRoot, 'src', 'sliceConfig.json');
+  const configPath = getConfigPath(import.meta.url, projectRoot);
   if (!(await fs.pathExists(configPath))) return [];
 
   try {
@@ -230,7 +238,7 @@ const collectJavaScriptFiles = async (dirPath) => {
 };
 
 const ensureNoCheckInPublicVendorFiles = async (projectRoot) => {
-  const configPath = path.join(projectRoot, 'src', 'sliceConfig.json');
+  const configPath = getConfigPath(import.meta.url, projectRoot);
   if (!(await fs.pathExists(configPath))) return { updatedFiles: 0, scannedFiles: 0 };
 
   let parsed;
@@ -245,7 +253,7 @@ const ensureNoCheckInPublicVendorFiles = async (projectRoot) => {
     .map((folder) => String(folder || '').trim())
     .filter(Boolean)
     .map((folder) => folder.replace(/^[/\\]+/, ''))
-    .map((folder) => path.join(projectRoot, 'src', folder));
+    .map((folder) => joinRoot(projectRoot, 'src', folder));
 
   const uniqueDirs = Array.from(new Set(candidateDirs));
   let scannedFiles = 0;
@@ -360,9 +368,11 @@ const readCategoryPathFromConfig = async (configPath, category) => {
 };
 
 const loadComponentStaticProps = async ({ projectRoot, registryMap }) => {
-  const configPath = path.join(projectRoot, 'src', 'sliceConfig.json');
+  const configPath = getConfigPath(import.meta.url, projectRoot);
   const categoryPathCache = new Map();
   const componentPropsMap = {};
+  let skippedCount = 0;
+  let processedCount = 0;
 
   for (const [componentName, category] of Object.entries(sortKeys(registryMap))) {
     if (!categoryPathCache.has(category)) {
@@ -372,26 +382,50 @@ const loadComponentStaticProps = async ({ projectRoot, registryMap }) => {
 
     const categoryPath = categoryPathCache.get(category);
     if (!categoryPath) {
+      skippedCount++;
       continue;
     }
 
-    const componentFile = path.join(projectRoot, 'src', categoryPath, componentName, `${componentName}.js`);
+    const componentFile = joinRoot(projectRoot, 'src', categoryPath, componentName, `${componentName}.js`);
     if (!(await fs.pathExists(componentFile))) {
+      skippedCount++;
+      continue;
+    }
+
+    let source;
+    try {
+      source = await fs.readFile(componentFile, 'utf8');
+    } catch (readError) {
+      Print.warning(`Cannot read ${componentFile}: ${readError.message}`);
+      skippedCount++;
       continue;
     }
 
-    const source = await fs.readFile(componentFile, 'utf8');
-    const props = extractStaticPropsFromSource(source);
-    componentPropsMap[componentName] = props || { [DYNAMIC_FALLBACK_PROP]: { type: 'any', required: false } };
+    const props = extractStaticPropsFromSource(source, componentFile);
+    if (props) {
+      componentPropsMap[componentName] = props;
+      processedCount++;
+    } else {
+      componentPropsMap[componentName] = { [DYNAMIC_FALLBACK_PROP]: { type: 'any', required: false } };
+    }
+  }
+
+  if (skippedCount > 0) {
+    Print.info(`Skipped ${skippedCount} component(s) with missing or unreadable files`);
   }
 
   return componentPropsMap;
 };
 
 const generateTypesFile = async ({ projectRoot, outputPath }) => {
-  const registryPath = path.join(projectRoot, 'src', 'Components', 'components.js');
-  const registryContent = await fs.readFile(registryPath, 'utf8');
-  const registryMap = parseComponentsRegistry(registryContent);
+  const registryPath = getComponentsJsPath(import.meta.url, projectRoot);
+  let registryContent;
+  try {
+    registryContent = await fs.readFile(registryPath, 'utf8');
+  } catch (readError) {
+    throw new Error(`Cannot read components registry at ${registryPath}: ${readError.message}`);
+  }
+  const registryMap = parseComponentsRegistry(registryContent, registryPath);
 
   const componentPropsMap = await loadComponentStaticProps({ projectRoot, registryMap });
 
@@ -412,12 +446,12 @@ const toPosixRelative = (projectRoot, targetPath) => {
 
 const ensureEditorConfigForTypes = async ({ projectRoot, outputPath }) => {
   try {
-    const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
+    const tsconfigPath = joinRoot(projectRoot, 'tsconfig.json');
     if (await fs.pathExists(tsconfigPath)) {
       return { mode: 'tsconfig_exists', filePath: tsconfigPath, includeAdded: false };
     }
 
-    const jsconfigPath = path.join(projectRoot, 'jsconfig.json');
+    const jsconfigPath = joinRoot(projectRoot, 'jsconfig.json');
     const declarationGlob = (() => {
       const relative = toPosixRelative(projectRoot, outputPath);
       if (!relative) return 'src/**/*.d.ts';
@@ -427,13 +461,17 @@ const ensureEditorConfigForTypes = async ({ projectRoot, outputPath }) => {
       return `${dir}/**/*.d.ts`;
     })();
 
-    if (!(await fs.pathExists(jsconfigPath))) {
+    const writeDefaultJsconfig = async () => {
       const jsconfig = {
         compilerOptions: { ...DEFAULT_EDITOR_COMPILER_OPTIONS },
         include: [...DEFAULT_EDITOR_INCLUDE, declarationGlob],
         exclude: [...DEFAULT_EDITOR_EXCLUDE]
       };
       await fs.writeFile(jsconfigPath, `${JSON.stringify(jsconfig, null, 2)}\n`, 'utf8');
+    };
+
+    if (!(await fs.pathExists(jsconfigPath))) {
+      await writeDefaultJsconfig();
       return { mode: 'created_jsconfig', filePath: jsconfigPath, includeAdded: true };
     }
 
@@ -441,14 +479,19 @@ const ensureEditorConfigForTypes = async ({ projectRoot, outputPath }) => {
     try {
       jsconfigRaw = await fs.readFile(jsconfigPath, 'utf8');
     } catch {
-      return { mode: 'jsconfig_unreadable', filePath: jsconfigPath, includeAdded: false };
+      // Don't fail — fall back to writing the default options.
+      await writeDefaultJsconfig();
+      return { mode: 'reset_jsconfig', reason: 'unreadable', filePath: jsconfigPath, includeAdded: true };
     }
 
     let parsed;
     try {
       parsed = JSON.parse(jsconfigRaw);
     } catch {
-      return { mode: 'jsconfig_invalid_json', filePath: jsconfigPath, includeAdded: false };
+      // The jsconfig was edited into invalid JSON (a typo, comments, trailing commas...).
+      // Don't fail — just write the default options so editor IntelliSense keeps working.
+      await writeDefaultJsconfig();
+      return { mode: 'reset_jsconfig', reason: 'invalid_json', filePath: jsconfigPath, includeAdded: true };
     }
 
     const include = Array.isArray(parsed.include) ? parsed.include : [];
@@ -513,12 +556,10 @@ const runGenerateTypes = async ({ projectRoot, outputPath }) => {
     Print.info(`jsconfig.json already includes declaration glob. Editor IntelliSense should pick generated types.`);
   } else if (editorConfig.mode === 'tsconfig_exists') {
     Print.info(`tsconfig.json detected. Types declaration is generated; ensure include covers ${toPosixRelative(projectRoot, outputPath)}.`);
-  } else if (editorConfig.mode === 'jsconfig_invalid_json') {
-    Print.warning(`Could not update jsconfig.json because it contains invalid JSON.`);
-    Print.info(`Fix ${editorConfig.filePath} and run 'slice types generate' again.`);
-  } else if (editorConfig.mode === 'jsconfig_unreadable') {
-    Print.warning(`Could not read jsconfig.json to verify declaration include.`);
-    Print.info(`Check permissions for ${editorConfig.filePath} and run 'slice types generate' again.`);
+  } else if (editorConfig.mode === 'reset_jsconfig') {
+    const why = editorConfig.reason === 'invalid_json' ? 'contained invalid JSON' : 'could not be read';
+    Print.warning(`jsconfig.json ${why}; wrote the default options so editor IntelliSense keeps working.`);
+    Print.info(`Review ${editorConfig.filePath} if you had custom settings there.`);
   } else if (editorConfig.mode === 'editor_config_error') {
     Print.warning(`Unexpected editor config setup error: ${editorConfig.errorMessage}`);
   }
@@ -534,5 +575,6 @@ export {
   extractStaticPropsFromSource,
   generateDeclarationContent,
   generateTypesFile,
+  parseComponentsRegistry,
   runGenerateTypes
 };

package/commands/utils/LocalCliDelegation.js

@@ -1,53 +1,53 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-function getParentDirectory(dir) {
-  const parent = path.dirname(dir);
-  return parent === dir ? null : parent;
-}
-
-export function isLocalDelegationDisabled(env = process.env) {
-  return env.SLICE_NO_LOCAL_DELEGATION === '1';
-}
-
-export function findNearestLocalCliEntry(startDirectory, resolveCandidate) {
-  if (!startDirectory || typeof resolveCandidate !== 'function') {
-    return null;
-  }
-
-  let current = path.resolve(startDirectory);
-  while (current) {
-    const candidate = resolveCandidate(current);
-    if (candidate) {
-      return candidate;
-    }
-    current = getParentDirectory(current);
-  }
-
-  return null;
-}
-
-export function resolveLocalCliCandidate(directory) {
-  const candidate = path.join(directory, 'node_modules', 'slicejs-cli', 'client.js');
-
-  try {
-    const stats = fs.statSync(candidate);
-    return stats.isFile() ? candidate : null;
-  } catch {
-    return null;
-  }
-}
-
-export function shouldDelegateToLocalCli(currentEntryPath, localEntryPath) {
-  if (!localEntryPath) {
-    return false;
-  }
-
-  try {
-    const currentReal = fs.realpathSync(currentEntryPath);
-    const localReal = fs.realpathSync(localEntryPath);
-    return currentReal !== localReal;
-  } catch {
-    return path.resolve(currentEntryPath) !== path.resolve(localEntryPath);
-  }
-}
+import fs from 'node:fs';
+import path from 'node:path';
+
+function getParentDirectory(dir) {
+  const parent = path.dirname(dir);
+  return parent === dir ? null : parent;
+}
+
+export function isLocalDelegationDisabled(env = process.env) {
+  return env.SLICE_NO_LOCAL_DELEGATION === '1';
+}
+
+export function findNearestLocalCliEntry(startDirectory, resolveCandidate) {
+  if (!startDirectory || typeof resolveCandidate !== 'function') {
+    return null;
+  }
+
+  let current = path.resolve(startDirectory);
+  while (current) {
+    const candidate = resolveCandidate(current);
+    if (candidate) {
+      return candidate;
+    }
+    current = getParentDirectory(current);
+  }
+
+  return null;
+}
+
+export function resolveLocalCliCandidate(directory) {
+  const candidate = path.join(directory, 'node_modules', 'slicejs-cli', 'client.js');
+
+  try {
+    const stats = fs.statSync(candidate);
+    return stats.isFile() ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+
+export function shouldDelegateToLocalCli(currentEntryPath, localEntryPath) {
+  if (!localEntryPath) {
+    return false;
+  }
+
+  try {
+    const currentReal = fs.realpathSync(currentEntryPath);
+    const localReal = fs.realpathSync(localEntryPath);
+    return currentReal !== localReal;
+  } catch {
+    return path.resolve(currentEntryPath) !== path.resolve(localEntryPath);
+  }
+}

package/commands/utils/PathHelper.js

@@ -1,68 +1,75 @@
-import path from 'path'
-import fs from 'fs-extra'
-import { fileURLToPath } from 'url'
-
-const sanitize = (s) => (s || '').replace(/^[/\\]+/, '')
-const dirOf = (url) => path.dirname(fileURLToPath(url))
-
-function candidates(moduleUrl) {
-  const dir = dirOf(moduleUrl)
-  return [
-    path.join(dir, '../../'),
-    path.join(dir, '../../../../')
-  ]
-}
-
-function resolveProjectRoot(moduleUrl) {
-  const initCwd = process.env.INIT_CWD
-  if (initCwd && fs.pathExistsSync(initCwd)) {
-    return initCwd
-  }
-
-  const cwd = process.cwd()
-  if (cwd && fs.pathExistsSync(cwd)) {
-    return cwd
-  }
-
-  const dirs = candidates(moduleUrl)
-  for (const root of dirs) {
-    const hasSrc = fs.pathExistsSync(path.join(root, 'src'))
-    const hasApi = fs.pathExistsSync(path.join(root, 'api'))
-    if (hasSrc || hasApi) return root
-  }
-  return dirs[1]
-}
-
-function joinProject(moduleUrl, ...segments) {
-  const root = resolveProjectRoot(moduleUrl)
-  const clean = segments.map(sanitize)
-  return path.join(root, ...clean)
-}
-
-export function getProjectRoot(moduleUrl) {
-  return resolveProjectRoot(moduleUrl)
-}
-
-export function getPath(moduleUrl, folder, ...segments) {
-  return joinProject(moduleUrl, folder, ...segments)
-}
-
-export function getSrcPath(moduleUrl, ...segments) {
-  return joinProject(moduleUrl, 'src', ...segments)
-}
-
-export function getApiPath(moduleUrl, ...segments) {
-  return joinProject(moduleUrl, 'api', ...segments)
-}
-
-export function getDistPath(moduleUrl, ...segments) {
-  return joinProject(moduleUrl, 'dist', ...segments)
-}
-
-export function getConfigPath(moduleUrl) {
-  return joinProject(moduleUrl, 'src', 'sliceConfig.json')
-}
-
-export function getComponentsJsPath(moduleUrl) {
-  return joinProject(moduleUrl, 'src', 'Components', 'components.js')
-}
+import path from 'path'
+import fs from 'fs-extra'
+import { fileURLToPath } from 'url'
+
+const sanitize = (s) => (s || '').replace(/^[/\\]+/, '')
+const dirOf = (url) => path.dirname(fileURLToPath(url))
+
+function candidates(moduleUrl) {
+  const dir = dirOf(moduleUrl)
+  return [
+    path.join(dir, '../../'),
+    path.join(dir, '../../../../')
+  ]
+}
+
+function resolveProjectRoot(moduleUrl) {
+  const initCwd = process.env.INIT_CWD
+  if (initCwd && fs.pathExistsSync(initCwd)) {
+    return initCwd
+  }
+
+  const cwd = process.cwd()
+  if (cwd && fs.pathExistsSync(cwd)) {
+    return cwd
+  }
+
+  const dirs = candidates(moduleUrl)
+  for (const root of dirs) {
+    const hasSrc = fs.pathExistsSync(path.join(root, 'src'))
+    const hasApi = fs.pathExistsSync(path.join(root, 'api'))
+    if (hasSrc || hasApi) return root
+  }
+  return dirs[1]
+}
+
+function joinProject(moduleUrl, ...segments) {
+  const root = resolveProjectRoot(moduleUrl)
+  const clean = segments.map(sanitize)
+  return path.join(root, ...clean)
+}
+
+export function getProjectRoot(moduleUrl) {
+  return resolveProjectRoot(moduleUrl)
+}
+
+export function getPath(moduleUrl, folder, ...segments) {
+  return joinProject(moduleUrl, folder, ...segments)
+}
+
+export function getSrcPath(moduleUrl, ...segments) {
+  return joinProject(moduleUrl, 'src', ...segments)
+}
+
+export function getApiPath(moduleUrl, ...segments) {
+  return joinProject(moduleUrl, 'api', ...segments)
+}
+
+export function getDistPath(moduleUrl, ...segments) {
+  return joinProject(moduleUrl, 'dist', ...segments)
+}
+
+export function getConfigPath(moduleUrl, root) {
+  if (root) return path.join(root, 'src', 'sliceConfig.json')
+  return joinProject(moduleUrl, 'src', 'sliceConfig.json')
+}
+
+export function getComponentsJsPath(moduleUrl, root) {
+  if (root) return path.join(root, 'src', 'Components', 'components.js')
+  return joinProject(moduleUrl, 'src', 'Components', 'components.js')
+}
+
+export function joinRoot(root, ...segments) {
+  const clean = segments.map(sanitize)
+  return path.join(root, ...clean)
+}