create-nativecore 0.1.0 → 0.2.0

package/template/scripts/remove-core-component.mjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+/**
+ * Core Component Removal Script
+ * Removes core component file and imports from preloadRegistry.ts
+ * 
+ * Usage:
+ *   node scripts/remove-core-component.mjs nc-button
+ *   npm run remove:core-component nc-button
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Get component name from command line
+const componentName = process.argv[2];
+
+if (!componentName) {
+  console.error('❌ Error: Component name is required');
+  console.log('\nUsage:');
+  console.log('  npm run remove:core-component <name>');
+  console.log('\nExample:');
+  console.log('  npm run remove:core-component nc-button');
+  process.exit(1);
+}
+
+// Validate component name format
+if (!/^[a-z][a-z0-9]*(-[a-z0-9]+)+$/.test(componentName)) {
+  console.error('❌ Error: Component name must be in kebab-case with at least one hyphen');
+  process.exit(1);
+}
+
+// Paths
+const componentsDir = path.resolve(__dirname, '..', 'src', 'components');
+const coreDir = path.join(componentsDir, 'core');
+const componentFile = path.join(coreDir, `${componentName}.ts`);
+const preloadFile = path.join(componentsDir, 'preloadRegistry.ts');
+
+console.log(`\n🗑️  Removing core component: ${componentName}\n`);
+
+// Step 1: Check if component file exists
+if (!fs.existsSync(componentFile)) {
+  console.error(`❌ Error: Core component file "${componentName}.ts" does not exist`);
+  console.log(`   Expected location: src/components/core/${componentName}.ts`);
+  process.exit(1);
+}
+
+// Step 2: Remove from preloadRegistry.ts
+let removedFromPreload = false;
+if (fs.existsSync(preloadFile)) {
+  let preloadContent = fs.readFileSync(preloadFile, 'utf-8');
+  const preloadPattern = new RegExp(`import\\s+['\"]\\./core/${componentName}\\.js['\"];?\\s*\\n`, 'g');
+  
+  if (preloadPattern.test(preloadContent)) {
+    preloadContent = preloadContent.replace(preloadPattern, '');
+    fs.writeFileSync(preloadFile, preloadContent);
+    console.log('✅ Removed from preloadRegistry.ts');
+    removedFromPreload = true;
+  } else {
+    console.log('⚠️  Import not found in preloadRegistry.ts (may have been manually removed)');
+  }
+} else {
+  console.log('⚠️  preloadRegistry.ts not found');
+}
+
+// Step 3: Find and list usages in codebase
+console.log(`\n🔍 Searching for <${componentName}> usage in codebase...`);
+
+const usagePattern = new RegExp(`<${componentName}[^>]*>`, 'g');
+const closingPattern = new RegExp(`</${componentName}>`, 'g');
+const usages = [];
+
+// Search in specific directories
+const searchDirs = [
+  path.resolve(__dirname, '..', 'src', 'views', 'pages'),
+  path.resolve(__dirname, '..', 'src', 'components'),
+  path.resolve(__dirname, '..', 'src', 'controllers'),
+  path.resolve(__dirname, '..', 'index.html'),
+];
+
+function searchDirectory(dirPath) {
+  if (!fs.existsSync(dirPath)) return;
+  
+  const stat = fs.statSync(dirPath);
+  
+  if (stat.isDirectory()) {
+    const files = fs.readdirSync(dirPath, { withFileTypes: true });
+    
+    for (const file of files) {
+      const fullPath = path.join(dirPath, file.name);
+      
+      if (file.isDirectory()) {
+        searchDirectory(fullPath);
+      } else if (file.name.endsWith('.html') || file.name.endsWith('.ts')) {
+        checkFileForUsage(fullPath);
+      }
+    }
+  } else if (stat.isFile()) {
+    checkFileForUsage(dirPath);
+  }
+}
+
+function checkFileForUsage(filePath) {
+  // Skip the component file itself
+  if (filePath === componentFile) return;
+  
+  const content = fs.readFileSync(filePath, 'utf-8');
+  const openingMatches = content.match(usagePattern);
+  const closingMatches = content.match(closingPattern);
+  
+  if (openingMatches || closingMatches) {
+    const relativePath = path.relative(path.resolve(__dirname, '..'), filePath);
+    usages.push({
+      file: relativePath,
+      count: (openingMatches?.length || 0) + (closingMatches?.length || 0)
+    });
+  }
+}
+
+searchDirs.forEach(searchDirectory);
+
+// Step 4: Display usages and warning
+if (usages.length > 0) {
+  console.log(`\n⚠️  WARNING: Found usage in ${usages.length} file(s):\n`);
+  
+  for (const usage of usages) {
+    console.log(`   - ${usage.file} (${usage.count} occurrence${usage.count > 1 ? 's' : ''})`);
+  }
+  
+  console.log(`\n⚠️  Core components are framework components used across the app.`);
+  console.log(`   Removing them may break functionality. Please review usages carefully.\n`);
+  console.log(`❌ Aborting removal. Please manually remove usages first.\n`);
+  process.exit(1);
+}
+
+// Step 5: Delete the component file
+try {
+  fs.unlinkSync(componentFile);
+  console.log(`✅ Deleted component file: src/components/core/${componentName}.ts`);
+} catch (error) {
+  console.error(`❌ Error deleting component file: ${error.message}`);
+  process.exit(1);
+}
+
+// Summary
+console.log(`\n✅ Core component "${componentName}" removed successfully!\n`);
+console.log('📝 Summary:');
+console.log(`   ✓ Deleted: src/components/core/${componentName}.ts`);
+if (removedFromPreload) {
+  console.log(`   ✓ Removed from: src/components/preloadRegistry.ts`);
+}
+console.log('');

package/template/scripts/remove-dev.mjs

@@ -0,0 +1,13 @@
+// scripts/remove-dev.mjs
+// Remove dev folder from dist for production builds
+import { rmSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const devPath = join(process.cwd(), 'dist', 'dev');
+
+if (existsSync(devPath)) {
+  rmSync(devPath, { recursive: true, force: true });
+  console.log('🗑️  Removed dist/dev folder (denc-only files excluded from production)');
+} else {
+  console.log('✓ No dist/dev folder found (already clean)');
+}

package/template/scripts/remove-view.mjs

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+
+/**
+ * View Removal Script
+ * Removes views (HTML pages) and their associated controllers
+ * 
+ * Usage:
+ *   node scripts/remove-view.mjs profile
+ *   npm run remove:view profile
+ */
+
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+import { fileURLToPath } from 'url';
+import { generateCfRouter } from './generate-cf-router.mjs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Get view name from command line
+const viewName = process.argv[2];
+
+if (!viewName) {
+  console.error('❌ Error: View name is required');
+  console.log('\nUsage:');
+  console.log('  npm run remove:view <name>');
+  console.log('\nExample:');
+  console.log('  npm run remove:view profile');
+  process.exit(1);
+}
+
+// Create readline interface for prompts
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout
+});
+
+// Promisify question
+function question(query) {
+  return new Promise(resolve => rl.question(query, resolve));
+}
+
+// Generate controller name (camelCase)
+const controllerName = viewName
+  .split('-')
+  .map((word, index) => 
+    index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)
+  )
+  .join('');
+
+async function removeView() {
+  try {
+    // Check for view in both public and protected folders
+    const publicViewPath = path.resolve(__dirname, '..', 'src', 'views', 'public', `${viewName}.html`);
+    const protectedViewPath = path.resolve(__dirname, '..', 'src', 'views', 'protected', `${viewName}.html`);
+    
+    let viewPath = null;
+    let isProtected = false;
+    
+    if (fs.existsSync(publicViewPath)) {
+      viewPath = publicViewPath;
+      isProtected = false;
+    } else if (fs.existsSync(protectedViewPath)) {
+      viewPath = protectedViewPath;
+      isProtected = true;
+    } else {
+      console.error(`❌ Error: View "${viewName}.html" not found in public or protected folders`);
+      rl.close();
+      process.exit(1);
+    }
+    
+    // Check for controller
+    const controllerPath = path.resolve(__dirname, '..', 'src', 'controllers', `${viewName}.controller.ts`);
+    const hasController = fs.existsSync(controllerPath);
+    
+    // Show what will be deleted
+    console.log('\n📋 Files to be deleted:');
+    console.log(`   - ${path.relative(process.cwd(), viewPath)}`);
+    if (hasController) {
+      console.log(`   - ${path.relative(process.cwd(), controllerPath)}`);
+    }
+    console.log('\n📝 Updates to be made:');
+    if (hasController) {
+      console.log('   - Remove from src/controllers/index.ts');
+    }
+    console.log('   - Remove from src/routes/routes.ts');
+    if (isProtected) {
+      console.log('   - Remove from protected routes array');
+    }
+    
+    // Confirm deletion
+    const confirm = await question('\n⚠️  Are you sure you want to delete this view? (y/n): ');
+    
+    if (confirm.toLowerCase() !== 'y') {
+      console.log('❌ Deletion cancelled');
+      rl.close();
+      process.exit(0);
+    }
+    
+    rl.close();
+    
+    // Delete view file
+    fs.unlinkSync(viewPath);
+    console.log(`✅ Deleted: ${path.relative(process.cwd(), viewPath)}`);
+    
+    // Delete controller if exists
+    if (hasController) {
+      fs.unlinkSync(controllerPath);
+      console.log(`✅ Deleted: ${path.relative(process.cwd(), controllerPath)}`);
+      
+      // Update controllers/index.ts
+      const controllersIndexPath = path.resolve(__dirname, '..', 'src', 'controllers', 'index.ts');
+      if (fs.existsSync(controllersIndexPath)) {
+        let indexContent = fs.readFileSync(controllersIndexPath, 'utf8');
+        
+        // Remove export line
+        const exportPattern = new RegExp(`export \\{ ${controllerName}Controller \\} from '\\.\\/${viewName}\\.controller\\.ts';\\n`, 'g');
+        indexContent = indexContent.replace(exportPattern, '');
+        
+        fs.writeFileSync(controllersIndexPath, indexContent);
+        console.log('✅ Updated: src/controllers/index.ts');
+      }
+    }
+    
+    // Update routes.ts
+    const routesPath = path.resolve(__dirname, '..', 'src', 'routes', 'routes.ts');
+    if (fs.existsSync(routesPath)) {
+      let routesContent = fs.readFileSync(routesPath, 'utf8');
+      
+      // No need to remove imports - using lazy loading (no imports at top)
+      
+      // Remove route registration (handles both lazy and non-lazy formats)
+      const routePattern = new RegExp(`\\s*\\.register\\('\\/${viewName}'[^\\n]*\\n`, 'g');
+      routesContent = routesContent.replace(routePattern, '');
+      
+      // Remove from protected routes array if needed
+      if (isProtected) {
+        const protectedRoutesRegex = /export const protectedRoutes = \[(.*?)\];/s;
+        const match = routesContent.match(protectedRoutesRegex);
+        
+        if (match) {
+          const routes = match[1]
+            .split(',')
+            .map(r => r.trim())
+            .filter(r => r && r !== `'/${viewName}'`);
+          
+          routesContent = routesContent.replace(
+            protectedRoutesRegex,
+            `export const protectedRoutes = [${routes.join(', ')}];`
+          );
+        }
+      }
+      
+      fs.writeFileSync(routesPath, routesContent);
+      console.log('✅ Updated: src/routes/routes.ts');
+      generateCfRouter();
+    }
+    
+    // Remove from navigation menus
+    try {
+      const indexPath = path.resolve(__dirname, '..', 'index.html');
+      let indexContent = fs.readFileSync(indexPath, 'utf-8');
+      
+      // Remove from sidebar (protected) or header (public)
+      const sidebarPattern = new RegExp(`<a href="\\/${viewName}"[^>]*class="sidebar-item ${viewName}-link"[^>]*>[\\s\\S]*?<\\/a>\\s*`, 'g');
+      const headerPattern = new RegExp(`<a href="\\/${viewName}"[^>]*class="nanc-link"[^>]*>[\\s\\S]*?<\\/a>\\s*`, 'g');
+      
+      indexContent = indexContent.replace(sidebarPattern, '');
+      indexContent = indexContent.replace(headerPattern, '');
+      
+      fs.writeFileSync(indexPath, indexContent);
+      console.log('✅ Removed from navigation');
+      
+      // Also update app-header.ts for public pages
+      if (!isProtected) {
+        const headerPath = path.resolve(__dirname, '..', 'src', 'components', 'app-header.ts');
+        if (fs.existsSync(headerPath)) {
+          let headerContent = fs.readFileSync(headerPath, 'utf-8');
+          const headerMobilePattern = new RegExp(`<a href="\\/${viewName}"[^>]*class="nanc-link"[^>]*>[\\s\\S]*?<\\/a>\\s*`, 'g');
+          headerContent = headerContent.replace(headerMobilePattern, '');
+          fs.writeFileSync(headerPath, headerContent);
+          console.log('✅ Removed from header component');
+        }
+      }
+    } catch (e) {
+      console.log(`⚠️  Could not remove from navigation (may need manual cleanup)`);
+    }
+    
+    console.log('\n✨ View removed successfully!\n');
+    
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    rl.close();
+    process.exit(1);
+  }
+}
+
+// Run the removal
+removeView();

package/template/scripts/strip-dev-blocks.mjs

@@ -0,0 +1,30 @@
+// scripts/strip-denc-blocks.mjs
+// Removes <!-- DEnc-ONLY-START --> ... <!-- DEnc-ONLY-END --> blocks from HTML files
+import { readFile, writeFile } from 'fs/promises';
+import { resolve } from 'path';
+
+const files = [
+  'index.html',
+  'dist/bot/index.html',
+  // Add more output HTML files as needed
+];
+
+const DEV_BLOCK_REGEX = /<!-- DEnc-ONLY-START -->(.|\n|\r)*?<!-- DEnc-ONLY-END -->/g;
+
+async function stripDevBlocks(file) {
+  try {
+    const path = resolve(process.cwd(), file);
+    let html = await readFile(path, 'utf8');
+    const cleaned = html.replace(DEV_BLOCK_REGEX, '');
+    if (cleaned !== html) {
+      await writeFile(path, cleaned, 'utf8');
+      console.log(`Stripped denc-only blocks from ${file}`);
+    }
+  } catch (err) {
+    // Ignore missing files
+  }
+}
+
+(async () => {
+  await Promise.all(files.map(stripDevBlocks));
+})();

package/template/scripts/watch-compile.mjs

@@ -0,0 +1,69 @@
+import { spawn } from 'child_process';
+
+const tscArgs = ['tsc', '--watch', '--preserveWatchOutput'];
+let aliasProcess = null;
+let aliasQueued = false;
+
+function runAlias() {
+    if (aliasProcess) {
+        aliasQueued = true;
+        return;
+    }
+
+    aliasProcess = spawn('npx', ['tsc-alias'], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        shell: true
+    });
+
+    aliasProcess.stdout.on('data', chunk => {
+        process.stdout.write(`[alias] ${chunk}`);
+    });
+
+    aliasProcess.stderr.on('data', chunk => {
+        process.stderr.write(`[alias] ${chunk}`);
+    });
+
+    aliasProcess.on('exit', code => {
+        if (code && code !== 0) {
+            process.stderr.write(`[alias] tsc-alias exited with code ${code}\n`);
+        }
+
+        aliasProcess = null;
+
+        if (aliasQueued) {
+            aliasQueued = false;
+            runAlias();
+        }
+    });
+}
+
+const tscProcess = spawn('npx', tscArgs, {
+    stdio: ['ignore', 'pipe', 'pipe'],
+    shell: true
+});
+
+function handleTscOutput(chunk, writer) {
+    const text = chunk.toString();
+    writer.write(text);
+
+    if (/Found 0 errors?\. Watching for file changes\./.test(text)) {
+        runAlias();
+    }
+}
+
+tscProcess.stdout.on('data', chunk => handleTscOutput(chunk, process.stdout));
+tscProcess.stderr.on('data', chunk => handleTscOutput(chunk, process.stderr));
+
+function shutdown(signal) {
+    if (aliasProcess) {
+        aliasProcess.kill(signal);
+    }
+    tscProcess.kill(signal);
+}
+
+process.on('SIGINT', () => shutdown('SIGINT'));
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+
+tscProcess.on('exit', code => {
+    process.exit(code ?? 0);
+});