slicejs-cli 2.5.1 → 2.7.0

package/commands/init/init.js

@@ -3,6 +3,8 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import ora from 'ora';
 import Print from '../Print.js';
+import { getProjectRoot, getApiPath, getSrcPath } from '../utils/PathHelper.js';
+import { execSync } from 'child_process';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -11,12 +13,39 @@ import { ComponentRegistry } from '../getComponent/getComponent.js';
 
 export default async function initializeProject(projectType) {
     try {
-        // Directorio de origen para API (mantener copia local)
-        let sliceBaseDir = path.join(__dirname, '../../../slicejs-web-framework');
-        let apiDir = path.join(sliceBaseDir, 'api');
-        let srcDir = path.join(sliceBaseDir, 'src');
-        let destinationApi = path.join(__dirname, '../../../../api');
-        let destinationSrc = path.join(__dirname, '../../../../src');
+        const projectRoot = getProjectRoot(import.meta.url);
+        const destinationApi = getApiPath(import.meta.url);
+        const destinationSrc = getSrcPath(import.meta.url);
+
+        const fwSpinner = ora('Ensuring latest Slice framework...').start();
+        let sliceBaseDir;
+        try {
+            const latest = execSync('npm view slicejs-web-framework version', { cwd: projectRoot }).toString().trim();
+            const installedPkgPath = path.join(projectRoot, 'node_modules', 'slicejs-web-framework', 'package.json');
+            let installed = null;
+            if (await fs.pathExists(installedPkgPath)) {
+                const pkg = await fs.readJson(installedPkgPath);
+                installed = pkg.version;
+            }
+            if (installed !== latest) {
+                execSync(`npm install slicejs-web-framework@${latest} --save`, { cwd: projectRoot, stdio: 'inherit' });
+            }
+            sliceBaseDir = path.join(projectRoot, 'node_modules', 'slicejs-web-framework');
+            fwSpinner.succeed(`slicejs-web-framework@${latest} ready`);
+        } catch (err) {
+            const fallback = path.join(path.dirname(fileURLToPath(import.meta.url)), '../../../slicejs-web-framework');
+            if (await fs.pathExists(fallback)) {
+                sliceBaseDir = fallback;
+                fwSpinner.warn('Using local slicejs-web-framework fallback');
+            } else {
+                fwSpinner.fail('Failed to ensure latest slicejs-web-framework');
+                Print.error(err.message);
+                return;
+            }
+        }
+
+        const apiDir = path.join(sliceBaseDir, 'api');
+        const srcDir = path.join(sliceBaseDir, 'src');
 
         try {
             // Verificar si los directorios de destino ya existen
@@ -131,6 +160,73 @@ export default async function initializeProject(projectType) {
             Print.info('You can add them later using "slice get <component-name>"');
         }
 
+        // 4. CONFIGURAR SCRIPTS EN package.json DEL PROYECTO
+        const pkgSpinner = ora('Configuring npm scripts...').start();
+        try {
+            const projectRoot = getProjectRoot(import.meta.url);
+            const pkgPath = path.join(projectRoot, 'package.json');
+
+            let pkg;
+            if (await fs.pathExists(pkgPath)) {
+                pkg = await fs.readJson(pkgPath);
+            } else {
+                pkg = {
+                    name: path.basename(projectRoot),
+                    version: '1.0.0',
+                    description: 'Slice.js project',
+                    main: 'api/index.js',
+                    scripts: {}
+                };
+            }
+
+            pkg.scripts = pkg.scripts || {};
+
+            // Comandos principales
+            pkg.scripts['dev'] = 'slice dev';
+            pkg.scripts['start'] = 'slice start';
+
+            // Gestión de componentes
+            pkg.scripts['component:create'] = 'slice component create';
+            pkg.scripts['component:list'] = 'slice component list';
+            pkg.scripts['component:delete'] = 'slice component delete';
+
+            // Atajos de repositorio
+            pkg.scripts['get'] = 'slice get';
+            pkg.scripts['browse'] = 'slice browse';
+            pkg.scripts['sync'] = 'slice sync';
+
+            // Utilidades
+            pkg.scripts['slice:version'] = 'slice version';
+            pkg.scripts['slice:update'] = 'slice update';
+
+            // Legacy (compatibilidad)
+            pkg.scripts['slice:init'] = 'slice init';
+            pkg.scripts['slice:start'] = 'slice start';
+            pkg.scripts['slice:dev'] = 'slice dev';
+            pkg.scripts['slice:create'] = 'slice component create';
+            pkg.scripts['slice:list'] = 'slice component list';
+            pkg.scripts['slice:delete'] = 'slice component delete';
+            pkg.scripts['slice:get'] = 'slice get';
+            pkg.scripts['slice:browse'] = 'slice browse';
+            pkg.scripts['slice:sync'] = 'slice sync';
+            pkg.scripts['run'] = 'slice dev';
+
+            // Configuración de módulo
+            pkg.type = pkg.type || 'module';
+            pkg.engines = pkg.engines || { node: '>=20.0.0' };
+
+            await fs.writeFile(pkgPath, JSON.stringify(pkg, null, 2), 'utf8');
+            pkgSpinner.succeed('npm scripts configured successfully');
+
+            console.log('\n🎯 New recommended commands:');
+            console.log('  npm run dev            - Start development server');
+            console.log('  npm run get            - Install components');
+            console.log('  npm run browse         - Browse components');
+        } catch (error) {
+            pkgSpinner.fail('Failed to configure npm scripts');
+            Print.error(error.message);
+        }
+
         Print.success('Proyecto inicializado correctamente.');
         Print.newLine();
         Print.info('Next steps:');
@@ -155,4 +251,4 @@ async function getAllVisualComponents(registry) {
     Print.info(`Found ${allVisualComponents.length} Visual components in official repository`);
 
     return allVisualComponents;
-}
+}

package/commands/listComponents/listComponents.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'url';
 import Table from 'cli-table3';
 import chalk from 'chalk';
 import Print from '../Print.js';
+import { getSrcPath, getComponentsJsPath, getConfigPath } from '../utils/PathHelper.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -13,7 +14,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
  */
 const loadConfig = () => {
     try {
-        const configPath = path.join(__dirname, '../../../../src/sliceConfig.json');
+        const configPath = getConfigPath(import.meta.url);
         if (!fs.existsSync(configPath)) {
             Print.error('sliceConfig.json not found');
             Print.info('Run "slice init" to initialize your project');
@@ -72,7 +73,8 @@ const getComponents = () => {
     let allComponents = new Map();
 
     Object.entries(componentPaths).forEach(([category, { path: folderPath }]) => {
-        const fullPath = path.join(__dirname, `../../../../${folderSuffix}`, folderPath);
+        const cleanFolderPath = folderPath ? folderPath.replace(/^[/\\]+/, '') : '';
+        const fullPath = getSrcPath(import.meta.url, cleanFolderPath);
         const files = listComponents(fullPath);
 
         files.forEach(file => {
@@ -150,7 +152,7 @@ function listComponentsReal() {
         Print.info(`Total: ${Object.keys(components).length} component${Object.keys(components).length !== 1 ? 's' : ''} found`);
 
         // Ruta donde se generará components.js
-        const outputPath = path.join(__dirname, '../../../../src/Components/components.js');
+        const outputPath = getComponentsJsPath(import.meta.url);
 
         // Asegurar que el directorio existe
         const outputDir = path.dirname(outputPath);

package/commands/startServer/startServer.js

@@ -7,6 +7,7 @@ import { spawn } from 'child_process';
 import { createServer } from 'net';
 import setupWatcher, { stopWatcher } from './watchServer.js';
 import Print from '../Print.js';
+import { getConfigPath, getApiPath, getSrcPath, getDistPath } from '../utils/PathHelper.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -15,7 +16,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
  */
 const loadConfig = () => {
   try {
-    const configPath = path.join(__dirname, '../../../../src/sliceConfig.json');
+    const configPath = getConfigPath(import.meta.url);
     const rawData = fs.readFileSync(configPath, 'utf-8');
     return JSON.parse(rawData);
   } catch (error) {
@@ -52,7 +53,7 @@ async function isPortAvailable(port) {
  * Verifica si existe un build de producción
  */
 async function checkProductionBuild() {
-  const distDir = path.join(__dirname, '../../../../dist');
+  const distDir = getDistPath(import.meta.url);
   return await fs.pathExists(distDir);
 }
 
@@ -60,8 +61,8 @@ async function checkProductionBuild() {
  * Verifica si existe la estructura de desarrollo
  */
 async function checkDevelopmentStructure() {
-  const srcDir = path.join(__dirname, '../../../../src');
-  const apiDir = path.join(__dirname, '../../../../api');
+  const srcDir = getSrcPath(import.meta.url);
+  const apiDir = getApiPath(import.meta.url);
 
   return (await fs.pathExists(srcDir)) && (await fs.pathExists(apiDir));
 }
@@ -71,7 +72,7 @@ async function checkDevelopmentStructure() {
  */
 function startNodeServer(port, mode) {
   return new Promise((resolve, reject) => {
-    const apiIndexPath = path.join(__dirname, '../../../../api/index.js');
+    const apiIndexPath = getApiPath(import.meta.url, 'index.js');
 
     // Verificar que el archivo existe
     if (!fs.existsSync(apiIndexPath)) {
@@ -235,4 +236,4 @@ export default async function startServer(options = {}) {
 /**
  * Funciones de utilidad exportadas
  */
-export { checkProductionBuild, checkDevelopmentStructure, isPortAvailable };
+export { checkProductionBuild, checkDevelopmentStructure, isPortAvailable };

package/commands/utils/PathHelper.js

@@ -0,0 +1,58 @@
+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 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')
+}

package/commands/utils/VersionChecker.js

@@ -1,9 +1,10 @@
 // commands/utils/VersionChecker.js
 
-import fs from "fs-extra";
-import path from "path";
-import { fileURLToPath } from "url";
-import Print from "../Print.js";
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+import Print from "../Print.js";
+import { getProjectRoot } from "../utils/PathHelper.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -22,8 +23,9 @@ class VersionChecker {
       const cliPackage = await fs.readJson(cliPackagePath);
       this.currentCliVersion = cliPackage.version;
 
-      // Get Framework version from node_modules
-      const frameworkPackagePath = path.join(__dirname, '../../../../node_modules/slicejs-web-framework/package.json');
+      // Get Framework version from project node_modules
+      const projectRoot = getProjectRoot(import.meta.url);
+      const frameworkPackagePath = path.join(projectRoot, 'node_modules', 'slicejs-web-framework', 'package.json');
       if (await fs.pathExists(frameworkPackagePath)) {
         const frameworkPackage = await fs.readJson(frameworkPackagePath);
         this.currentFrameworkVersion = frameworkPackage.version;
@@ -162,4 +164,4 @@ class VersionChecker {
 // Singleton instance
 const versionChecker = new VersionChecker();
 
-export default versionChecker;
+export default versionChecker;

package/commands/utils/updateManager.js

@@ -0,0 +1,377 @@
+// commands/utils/updateManager.js
+
+import { exec } from "child_process";
+import { promisify } from "util";
+import inquirer from "inquirer";
+import ora from "ora";
+import Print from "../Print.js";
+import versionChecker from "./VersionChecker.js";
+import { getProjectRoot } from "../utils/PathHelper.js";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const execAsync = promisify(exec);
+
+class UpdateManager {
+    constructor() {
+        this.packagesToUpdate = [];
+    }
+
+    async detectCliInstall() {
+        try {
+            const moduleDir = path.dirname(fileURLToPath(import.meta.url));
+            const cliRoot = path.join(moduleDir, '../../');
+            const projectRoot = getProjectRoot(import.meta.url);
+            let globalPrefix = '';
+            try {
+                const { stdout } = await execAsync('npm config get prefix');
+                globalPrefix = stdout.toString().trim();
+            } catch {}
+            const localNodeModules = path.join(projectRoot, 'node_modules');
+            const globalNodeModules = globalPrefix ? path.join(globalPrefix, 'node_modules') : '';
+
+            if (cliRoot.startsWith(localNodeModules)) {
+                return { type: 'local', cliRoot, projectRoot, globalPrefix };
+            }
+            if (globalNodeModules && cliRoot.startsWith(globalNodeModules)) {
+                return { type: 'global', cliRoot, projectRoot, globalPrefix };
+            }
+            return { type: 'unknown', cliRoot, projectRoot, globalPrefix };
+        } catch (error) {
+            return { type: 'unknown' };
+        }
+    }
+
+    /**
+     * Check for available updates and return structured info
+     */
+    async checkForUpdates() {
+        try {
+            const updateInfo = await versionChecker.checkForUpdates(true); // Silent mode
+
+            if (!updateInfo) {
+                return null;
+            }
+
+            const updates = [];
+
+            if (updateInfo.cli.status === 'outdated') {
+                updates.push({
+                    name: 'slicejs-cli',
+                    displayName: 'Slice.js CLI',
+                    current: updateInfo.cli.current,
+                    latest: updateInfo.cli.latest,
+                    type: 'cli'
+                });
+            }
+
+            if (updateInfo.framework.status === 'outdated') {
+                updates.push({
+                    name: 'slicejs-web-framework',
+                    displayName: 'Slice.js Framework',
+                    current: updateInfo.framework.current,
+                    latest: updateInfo.framework.latest,
+                    type: 'framework'
+                });
+            }
+
+            return {
+                hasUpdates: updates.length > 0,
+                updates,
+                allCurrent: updateInfo.cli.status === 'current' && updateInfo.framework.status === 'current'
+            };
+        } catch (error) {
+            Print.error(`Checking for updates: ${error.message}`);
+            return null;
+        }
+    }
+
+    /**
+     * Display available updates in a formatted way
+     */
+    displayUpdates(updateInfo) {
+        if (!updateInfo || !updateInfo.hasUpdates) {
+            return;
+        }
+
+        console.log('');
+        Print.warning('📦 Actualizaciones Disponibles:');
+        console.log('');
+
+        updateInfo.updates.forEach(pkg => {
+            console.log(`   ${pkg.type === 'cli' ? '🔧' : '⚡'} ${pkg.displayName}`);
+            console.log(`      ${pkg.current} → ${pkg.latest}`);
+        });
+
+        console.log('');
+        console.log('   📚 Changelog: https://github.com/VKneider/slice.js/releases');
+        console.log('');
+    }
+
+    /**
+     * Prompt user to select which packages to update
+     */
+    async promptForUpdates(updateInfo, options = {}) {
+        if (!updateInfo || !updateInfo.hasUpdates) {
+            return [];
+        }
+
+        // If --yes flag is set, return all updates
+        if (options.yes) {
+            return updateInfo.updates.map(pkg => pkg.name);
+        }
+
+        // If specific package flags are set
+        if (options.cli || options.framework) {
+            const selected = [];
+            if (options.cli) {
+                const cliUpdate = updateInfo.updates.find(pkg => pkg.type === 'cli');
+                if (cliUpdate) selected.push(cliUpdate.name);
+            }
+            if (options.framework) {
+                const frameworkUpdate = updateInfo.updates.find(pkg => pkg.type === 'framework');
+                if (frameworkUpdate) selected.push(frameworkUpdate.name);
+            }
+            return selected;
+        }
+
+        // Interactive selection
+        const choices = updateInfo.updates.map(pkg => ({
+            name: `${pkg.displayName} (${pkg.current} → ${pkg.latest})`,
+            value: pkg.name,
+            checked: true
+        }));
+
+        const answers = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'packages',
+                message: '¿Qué paquetes deseas actualizar?',
+                choices,
+                validate: (answer) => {
+                    if (answer.length === 0) {
+                        return 'Debes seleccionar al menos un paquete';
+                    }
+                    return true;
+                }
+            }
+        ]);
+
+        return answers.packages;
+    }
+
+    async buildUpdatePlan(packages) {
+        const plan = [];
+        const info = await this.detectCliInstall();
+        for (const pkg of packages) {
+            if (pkg === 'slicejs-cli') {
+                if (info.type === 'global') {
+                    plan.push({ package: pkg, target: 'global', command: 'npm install -g slicejs-cli@latest' });
+                } else {
+                    plan.push({ package: pkg, target: 'project', command: 'npm install slicejs-cli@latest' });
+                }
+            } else if (pkg === 'slicejs-web-framework') {
+                plan.push({ package: pkg, target: 'project', command: 'npm install slicejs-web-framework@latest' });
+            } else {
+                plan.push({ package: pkg, target: 'project', command: `npm install ${pkg}@latest` });
+            }
+        }
+        return plan;
+    }
+
+    /**
+     * Execute npm update command for a specific package
+     */
+    async updatePackage(packageName) {
+        try {
+            let command = `npm install ${packageName}@latest`;
+            let options = {};
+
+            if (packageName === 'slicejs-cli') {
+                const info = await this.detectCliInstall();
+                if (info.type === 'global') {
+                    command = `npm install -g slicejs-cli@latest`;
+                } else {
+                    options.cwd = info.projectRoot || getProjectRoot(import.meta.url);
+                }
+            } else {
+                options.cwd = getProjectRoot(import.meta.url);
+            }
+
+            const { stdout, stderr } = await execAsync(command, options);
+
+            return {
+                success: true,
+                packageName,
+                stdout,
+                stderr
+            };
+        } catch (error) {
+            return {
+                success: false,
+                packageName,
+                error: error.message
+            };
+        }
+    }
+
+    /**
+     * Update multiple packages with progress indication
+     */
+    async installUpdates(packages) {
+        const results = [];
+
+        for (const packageName of packages) {
+            const spinner = ora(`Actualizando ${packageName}...`).start();
+
+            try {
+                const result = await this.updatePackage(packageName);
+
+                if (result.success) {
+                    spinner.succeed(`${packageName} actualizado exitosamente`);
+                    results.push({ packageName, success: true });
+                } else {
+                    spinner.fail(`Error actualizando ${packageName}`);
+                    Print.error(`Detalles: ${result.error}`);
+                    results.push({ packageName, success: false, error: result.error });
+                }
+            } catch (error) {
+                spinner.fail(`Error actualizando ${packageName}`);
+                Print.error(`Detalles: ${error.message}`);
+                results.push({ packageName, success: false, error: error.message });
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Main method to check and prompt for updates
+     */
+    async checkAndPromptUpdates(options = {}) {
+        const spinner = ora('Verificando actualizaciones...').start();
+
+        try {
+            const updateInfo = await this.checkForUpdates();
+            spinner.stop();
+
+            if (!updateInfo) {
+                Print.error('No se pudo verificar actualizaciones. Verifica tu conexión a internet.');
+                return false;
+            }
+
+            if (updateInfo.allCurrent) {
+                Print.success('✅ Todos los componentes están actualizados!');
+                return true;
+            }
+
+            if (!updateInfo.hasUpdates) {
+                Print.success('✅ Todos los componentes están actualizados!');
+                return true;
+            }
+
+            // Display available updates
+            this.displayUpdates(updateInfo);
+
+        // Get packages to update
+        const packagesToUpdate = await this.promptForUpdates(updateInfo, options);
+
+            if (!packagesToUpdate || packagesToUpdate.length === 0) {
+                Print.info('No se seleccionaron paquetes para actualizar.');
+                return false;
+            }
+
+        // Show plan and confirm installation if not auto-confirmed
+        let plan = await this.buildUpdatePlan(packagesToUpdate);
+        console.log('');
+        Print.info('🧭 Plan de actualización:');
+        plan.forEach(item => {
+            const where = item.target === 'global' ? 'GLOBAL' : 'PROYECTO';
+            console.log(`   • ${item.package} → ${where}`);
+            console.log(`     ${item.command}`);
+        });
+        console.log('');
+
+        const cliInfo = await this.detectCliInstall();
+        if (cliInfo.type === 'global' && !packagesToUpdate.includes('slicejs-cli')) {
+            if (!options.yes && !options.cli) {
+                const { addCli } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'addCli',
+                        message: 'Se detectó CLI global. ¿Agregar la actualización global del CLI al plan?',
+                        default: true
+                    }
+                ]);
+                if (addCli) {
+                    packagesToUpdate.push('slicejs-cli');
+                    plan = await this.buildUpdatePlan(packagesToUpdate);
+                    console.log('');
+                    Print.info('🧭 Plan actualizado:');
+                    plan.forEach(item => {
+                        const where = item.target === 'global' ? 'GLOBAL' : 'PROYECTO';
+                        console.log(`   • ${item.package} → ${where}`);
+                        console.log(`     ${item.command}`);
+                    });
+                    console.log('');
+                }
+            } else {
+                Print.warning('CLI global detectado. Se recomienda actualizar slicejs-cli global para mantener alineado con el framework.');
+                console.log('   Sugerencia: npm install -g slicejs-cli@latest');
+                console.log('');
+            }
+        }
+
+        if (!options.yes && !options.cli && !options.framework) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: '¿Deseas continuar con la actualización según el plan mostrado?',
+                    default: true
+                }
+            ]);
+
+                if (!confirm) {
+                    Print.info('Actualización cancelada.');
+                    return false;
+                }
+            }
+
+            console.log(''); // Line break
+            Print.info('📥 Instalando actualizaciones...');
+            console.log('');
+
+            // Install updates
+            const results = await this.installUpdates(packagesToUpdate);
+
+            // Summary
+            console.log('');
+            const successCount = results.filter(r => r.success).length;
+            const failCount = results.filter(r => !r.success).length;
+
+            if (failCount === 0) {
+                Print.success(`✅ ${successCount} paquete(s) actualizado(s) exitosamente!`);
+            } else {
+                Print.warning(`⚠️  ${successCount} exitoso(s), ${failCount} fallido(s)`);
+            }
+
+            if (successCount > 0) {
+                console.log('');
+                Print.info('💡 Se recomienda reiniciar el servidor de desarrollo si está ejecutándose.');
+            }
+
+            return failCount === 0;
+
+        } catch (error) {
+            spinner.stop();
+            Print.error(`Error durante la actualización: ${error.message}`);
+            return false;
+        }
+    }
+}
+
+// Singleton instance
+const updateManager = new UpdateManager();
+
+export default updateManager;