frontend-hamroun 1.2.0 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "frontend-hamroun",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "A lightweight frontend and backend framework for building modern web applications",
   "type": "module",
   "main": "dist/frontend-hamroun.umd.js",
@@ -22,11 +22,12 @@
     }
   },
   "bin": {
-    "hamroun": "src/cli/index.js"
+    "hamroun": "./dist/cli/index.js",
+    "frontend-hamroun": "./dist/cli/index.js"
   },
   "scripts": {
     "dev": "vite",
-    "build": "vite build && tsc",
+    "build": "vite build && tsc && node scripts/build-cli.js",
     "test": "jest",
     "clean": "rimraf dist",
     "prebuild": "npm run clean",

package/scripts/build-cli.js

@@ -0,0 +1,81 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { exec } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.resolve(__dirname, '..');
+const cliDistDir = path.resolve(rootDir, 'dist/cli');
+
+// Ensure CLI dist directory exists
+if (!fs.existsSync(cliDistDir)) {
+  fs.mkdirSync(cliDistDir, { recursive: true });
+}
+
+// Create CLI index.js in dist
+const cliIndexPath = path.resolve(cliDistDir, 'index.js');
+fs.writeFileSync(cliIndexPath, `#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import { createRequire } from 'module';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const require = createRequire(import.meta.url);
+
+// Re-export the CLI from the compiled TypeScript
+import('../cli/index.js').catch(err => {
+  console.error('Failed to load CLI:', err);
+  process.exit(1);
+});
+`, 'utf8');
+
+// Make the CLI executable
+try {
+  fs.chmodSync(cliIndexPath, '755');
+  console.log('CLI built successfully: dist/cli/index.js');
+} catch (error) {
+  console.warn('Could not make CLI executable:', error);
+}
+
+// Create template directories in dist if missing
+const templateSrcDir = path.resolve(rootDir, 'templates');
+const templateDistDir = path.resolve(rootDir, 'dist/templates');
+
+// Copy templates recursively
+function copyTemplates() {
+  try {
+    if (!fs.existsSync(templateDistDir)) {
+      fs.mkdirSync(templateDistDir, { recursive: true });
+    }
+    
+    // Copy each template
+    const templates = fs.readdirSync(templateSrcDir);
+    
+    for (const template of templates) {
+      const srcTemplatePath = path.join(templateSrcDir, template);
+      const distTemplatePath = path.join(templateDistDir, template);
+      
+      if (fs.statSync(srcTemplatePath).isDirectory()) {
+        if (!fs.existsSync(distTemplatePath)) {
+          fs.mkdirSync(distTemplatePath, { recursive: true });
+        }
+        
+        // Use cp -r for recursively copying
+        exec(`cp -r ${srcTemplatePath}/* ${distTemplatePath}`, (error) => {
+          if (error) {
+            console.error(`Error copying template ${template}:`, error);
+          } else {
+            console.log(`Copied template ${template} to dist`);
+          }
+        });
+      }
+    }
+  } catch (error) {
+    console.error('Error copying templates:', error);
+  }
+}
+
+copyTemplates();

package/src/cli/index.ts

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import readline from 'readline';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Get package.json to read version
+const packageJsonPath = path.resolve(__dirname, '../../package.json');
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+// Available templates
+const TEMPLATES = {
+  'basic': 'Basic frontend only template',
+  'full-stack': 'Complete frontend and backend template',
+  'api-only': 'Backend API only template'
+};
+
+// CLI colors
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m'
+};
+
+// Create readline interface
+function createInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+// Print banner
+function printBanner() {
+  console.log(`
+${colors.blue}${colors.bright}╔══════════════════════════════════════════════╗
+║                                              ║
+║   Frontend Hamroun v${packageJson.version.padEnd(25)}║
+║   A lightweight frontend & backend framework  ║
+║                                              ║
+╚══════════════════════════════════════════════╝${colors.reset}
+  `);
+}
+
+// Print help
+function printHelp() {
+  console.log(`
+${colors.bright}USAGE:${colors.reset}
+  ${colors.blue}npx frontend-hamroun${colors.reset} [command] [options]
+
+${colors.bright}COMMANDS:${colors.reset}
+  ${colors.blue}create${colors.reset} <project-name> [options]  Create a new project
+  ${colors.blue}help${colors.reset}                           Display this help message
+  ${colors.blue}version${colors.reset}                        Display version information
+
+${colors.bright}OPTIONS:${colors.reset}
+  ${colors.blue}--template${colors.reset}, ${colors.blue}-t${colors.reset} <template>       Specify template (default: basic)
+  ${colors.blue}--skip-install${colors.reset}, ${colors.blue}-s${colors.reset}            Skip package installation
+
+${colors.bright}AVAILABLE TEMPLATES:${colors.reset}
+${Object.entries(TEMPLATES).map(([name, desc]) => `  ${colors.blue}${name.padEnd(12)}${colors.reset} ${desc}`).join('\n')}
+
+${colors.bright}EXAMPLES:${colors.reset}
+  ${colors.blue}npx frontend-hamroun create${colors.reset} my-app
+  ${colors.blue}npx frontend-hamroun create${colors.reset} my-app --template full-stack
+  ${colors.blue}npx frontend-hamroun create${colors.reset} my-api -t api-only --skip-install
+  `);
+}
+
+// Create project from template
+async function createProject(projectName, options) {
+  const template = options.template || 'basic';
+  
+  // Check if template exists
+  if (!Object.keys(TEMPLATES).includes(template)) {
+    console.error(`${colors.red}error:${colors.reset} Template "${template}" not found.`);
+    console.log(`Available templates: ${Object.keys(TEMPLATES).join(', ')}`);
+    process.exit(1);
+  }
+  
+  // Check if project directory already exists
+  const projectPath = path.resolve(process.cwd(), projectName);
+  if (fs.existsSync(projectPath)) {
+    console.error(`${colors.red}error:${colors.reset} Directory ${projectName} already exists.`);
+    process.exit(1);
+  }
+  
+  console.log(`
+${colors.bright}Creating a new project with Frontend Hamroun...${colors.reset}
+${colors.blue}• Project name:${colors.reset} ${projectName}
+${colors.blue}• Template:${colors.reset} ${template}
+${colors.blue}• Directory:${colors.reset} ${projectPath}
+  `);
+  
+  try {
+    // Find templates directory
+    const templateDir = path.resolve(__dirname, '../../templates', template);
+    
+    // Create project directory
+    fs.mkdirSync(projectPath, { recursive: true });
+    
+    // Copy template files
+    copyTemplateFiles(templateDir, projectPath);
+    
+    // Update package.json with project name
+    const projectPackageJsonPath = path.join(projectPath, 'package.json');
+    if (fs.existsSync(projectPackageJsonPath)) {
+      const projectPackageJson = JSON.parse(fs.readFileSync(projectPackageJsonPath, 'utf8'));
+      projectPackageJson.name = projectName;
+      fs.writeFileSync(
+        projectPackageJsonPath, 
+        JSON.stringify(projectPackageJson, null, 2)
+      );
+    }
+    
+    // Install dependencies
+    if (!options.skipInstall) {
+      console.log(`\n${colors.blue}Installing dependencies...${colors.reset}`);
+      
+      const command = getPackageManager() === 'yarn' 
+        ? 'yarn' 
+        : 'npm install';
+      
+      execSync(command, { 
+        cwd: projectPath, 
+        stdio: 'inherit' 
+      });
+    }
+    
+    // Success message
+    console.log(`
+${colors.green}${colors.bright}Success!${colors.reset} Created ${projectName} at ${projectPath}
+
+${colors.blue}Inside that directory, you can run several commands:${colors.reset}
+
+  ${colors.bright}npm run dev${colors.reset}
+    Starts the development server.
+
+  ${colors.bright}npm run build${colors.reset}
+    Builds the app for production.
+
+  ${colors.bright}npm start${colors.reset}
+    Runs the built app in production mode.
+
+${colors.blue}We suggest that you begin by typing:${colors.reset}
+
+  ${colors.bright}cd${colors.reset} ${projectName}
+  ${colors.bright}npm run dev${colors.reset}
+
+${colors.green}Happy coding!${colors.reset}
+    `);
+    
+  } catch (error) {
+    console.error(`${colors.red}Failed to create project:${colors.reset}`, error);
+    process.exit(1);
+  }
+}
+
+// Copy template files recursively
+function copyTemplateFiles(source, destination) {
+  const files = fs.readdirSync(source);
+  
+  for (const file of files) {
+    const sourcePath = path.join(source, file);
+    const destPath = path.join(destination, file);
+    
+    const stats = fs.statSync(sourcePath);
+    
+    if (stats.isDirectory()) {
+      fs.mkdirSync(destPath, { recursive: true });
+      copyTemplateFiles(sourcePath, destPath);
+    } else {
+      fs.copyFileSync(sourcePath, destPath);
+    }
+  }
+  
+  console.log(`${colors.green}•${colors.reset} Copied template files`);
+}
+
+// Detect package manager
+function getPackageManager() {
+  try {
+    const userAgent = process.env.npm_config_user_agent;
+    if (userAgent && userAgent.startsWith('yarn')) {
+      return 'yarn';
+    }
+    return 'npm';
+  } catch (error) {
+    return 'npm';
+  }
+}
+
+// Parse command line arguments
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  
+  if (!command || command === 'help') {
+    printBanner();
+    printHelp();
+    process.exit(0);
+  }
+  
+  if (command === 'version') {
+    console.log(`frontend-hamroun v${packageJson.version}`);
+    process.exit(0);
+  }
+  
+  if (command === 'create') {
+    const projectName = args[1];
+    
+    if (!projectName) {
+      console.error(`${colors.red}error:${colors.reset} Project name is required.`);
+      console.log(`Run ${colors.blue}npx frontend-hamroun help${colors.reset} for usage information.`);
+      process.exit(1);
+    }
+    
+    // Parse options
+    const options = {
+      template: 'basic',
+      skipInstall: false
+    };
+    
+    for (let i = 2; i < args.length; i++) {
+      if (args[i] === '--template' || args[i] === '-t') {
+        options.template = args[++i];
+      } else if (args[i] === '--skip-install' || args[i] === '-s') {
+        options.skipInstall = true;
+      }
+    }
+    
+    printBanner();
+    createProject(projectName, options);
+    return;
+  }
+  
+  console.error(`${colors.red}error:${colors.reset} Unknown command: ${command}`);
+  console.log(`Run ${colors.blue}npx frontend-hamroun help${colors.reset} for usage information.`);
+  process.exit(1);
+}
+
+// Run CLI
+parseArgs();

package/templates/full-stack/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Frontend Hamroun App</title>
+  <link rel="stylesheet" href="/src/main.css">
+</head>
+<body>
+  <div id="app"></div>
+  <script type="module" src="/src/main.ts"></script>
+</body>
+</html>

package/templates/full-stack/package.json

@@ -1,43 +1,50 @@
 {
-  "name": "{{projectName}}",
+  "name": "frontend-hamroun-app",
+  "private": true,
   "version": "0.1.0",
   "description": "{{description}}",
   "author": "{{author}}",
   "license": "MIT",
   "type": "module",
   "scripts": {
-    "dev": "concurrently \"npm run dev:server\" \"npm run dev:client\"",
-    "dev:server": "nodemon --watch src/server --exec \"ts-node src/server/index.ts\"",
-    "dev:client": "vite",
-    "build": "vite build && tsc --project tsconfig.server.json",
-    "start": "node dist/server/index.js",
-    "test": "jest"
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
+    "start": "node dist/server.js",
+    "dev:server": "ts-node-esm --transpile-only src/server.ts",
+    "dev:full": "concurrently \"npm run dev\" \"npm run dev:server\""
   },
   "dependencies": {
+    "frontend-hamroun": "latest",
     "express": "^4.18.2",
-    "frontend-hamroun": "^1.0.0",
+    "compression": "^1.7.4",
+    "helmet": "^7.0.0",
+    "morgan": "^1.10.0",
     "mongoose": "^7.0.0",
     "bcrypt": "^5.1.0",
     "jsonwebtoken": "^9.0.0",
-    "compression": "^1.7.4",
     "cookie-parser": "^1.4.6",
-    "dotenv": "^16.0.3",
-    "helmet": "^6.0.1"
+    "dotenv": "^16.0.3"
   },
   "devDependencies": {
+    "@tailwindcss/forms": "^0.5.7",
+    "@tailwindcss/typography": "^0.5.10",
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.10.0",
+    "autoprefixer": "^10.4.16",
+    "concurrently": "^8.2.2",
+    "postcss": "^8.4.31",
+    "tailwindcss": "^3.3.5",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.2",
+    "vite": "^5.0.0",
     "@types/bcrypt": "^5.0.0",
     "@types/compression": "^1.7.2",
     "@types/cookie-parser": "^1.4.3",
-    "@types/express": "^4.17.17",
     "@types/jest": "^29.5.0",
     "@types/jsonwebtoken": "^9.0.1",
-    "@types/node": "^18.15.0",
-    "concurrently": "^7.6.0",
     "jest": "^29.5.0",
     "nodemon": "^2.0.21",
-    "ts-jest": "^29.0.5",
-    "ts-node": "^10.9.1",
-    "typescript": "^4.9.5",
-    "vite": "^4.1.4"
+    "ts-jest": "^29.0.5"
   }
 }

package/templates/full-stack/src/main.css

@@ -0,0 +1,3 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;

package/templates/full-stack/src/main.ts

@@ -0,0 +1,20 @@
+import './main.css';
+import { render } from 'frontend-hamroun';
+import { App } from './App';
+import { createApiClient } from './api';
+
+// Initialize API client
+const api = createApiClient({
+  baseUrl: '/api'
+});
+
+// Render the app into the DOM
+document.addEventListener('DOMContentLoaded', () => {
+  const rootElement = document.getElementById('app');
+  if (rootElement) {
+    render(<App api={api} />, rootElement);
+    console.log('App rendered successfully');
+  } else {
+    console.error('Root element #app not found');
+  }
+});