frontend-hamroun 1.2.16 → 1.2.17

package/dist/backend/types.d.ts

@@ -1,217 +0,0 @@
-import { Request, Response, NextFunction, RequestHandler } from 'express';
-import { DatabaseConnector } from './database';
-/**
- * Options for configuring a Hamroun server
- */
-export interface HamrounServerOptions {
-    /**
-     * Port to run the server on (default: 3000)
-     */
-    port?: number;
-    /**
-     * Directory to serve static files from (default: 'public')
-     */
-    staticDir?: string;
-    /**
-     * Enable CORS headers (default: true)
-     */
-    enableCors?: boolean;
-    /**
-     * Prefix for API routes (default: '/api')
-     */
-    apiPrefix?: string;
-    /**
-     * Enable server-side rendering (default: true)
-     */
-    ssrEnabled?: boolean;
-    /**
-     * Additional Express middleware to apply
-     */
-    middlewares?: RequestHandler[];
-    /**
-     * Enable response compression (default: true)
-     */
-    enableCompression?: boolean;
-    /**
-     * Enable helmet security headers (default: true)
-     */
-    enableHelmet?: boolean;
-    /**
-     * Disable Content Security Policy (default: false)
-     */
-    disableCSP?: boolean;
-    /**
-     * Logging format for Morgan (default: 'dev')
-     */
-    logFormat?: string | null;
-    /**
-     * Trust proxy headers (default: false)
-     */
-    trustProxy?: boolean | string | number | string[] | number[];
-    /**
-     * Static file cache age (default: '1d')
-     */
-    staticCacheAge?: string;
-    /**
-     * Show detailed error information in responses (default: false)
-     */
-    showErrorDetails?: boolean;
-}
-/**
- * Options for router configuration
- */
-export interface RouterOptions {
-    /**
-     * Prefix to apply to all routes (overrides server apiPrefix)
-     */
-    prefix?: string;
-    /**
-     * Enable authentication for all routes in this router
-     */
-    requireAuth?: boolean;
-    /**
-     * Required role for all routes in this router
-     */
-    requiredRole?: string | string[];
-    /**
-     * Enable rate limiting for this router
-     */
-    rateLimit?: {
-        windowMs: number;
-        max: number;
-        message?: string;
-    };
-}
-/**
- * Context provided to route handlers
- */
-export interface RouteContext {
-    req: Request;
-    res: Response;
-    next: NextFunction;
-    params: any;
-    query: any;
-    body: any;
-    user?: any;
-}
-/**
- * Pagination options
- */
-export interface PaginationOptions {
-    page: number;
-    limit: number;
-    sort?: string;
-    order?: 'asc' | 'desc';
-}
-/**
- * Paginated result
- */
-export interface PaginatedResult<T> {
-    data: T[];
-    pagination: {
-        total: number;
-        totalPages: number;
-        currentPage: number;
-        limit: number;
-        hasNextPage: boolean;
-        hasPrevPage: boolean;
-    };
-}
-/**
- * Database connection options
- */
-export interface DatabaseOptions {
-    /**
-     * URI to connect to the database
-     */
-    uri: string;
-    /**
-     * Database name
-     */
-    name: string;
-    /**
-     * Connection options
-     */
-    options?: Record<string, any>;
-    /**
-     * Number of retry attempts (default: 3)
-     */
-    retryAttempts?: number;
-    /**
-     * Retry delay in ms (default: 1000)
-     */
-    retryDelay?: number;
-    /**
-     * Connection timeout in ms (default: 10000)
-     */
-    connectionTimeout?: number;
-    /**
-     * Auto-index creation (default: true)
-     */
-    autoIndex?: boolean;
-}
-/**
- * Data model structure
- */
-export interface Model<T> {
-    /**
-     * Get all documents
-     */
-    getAll: (options?: PaginationOptions) => Promise<PaginatedResult<T>>;
-    /**
-     * Get document by ID
-     */
-    getById: (id: string) => Promise<T | null>;
-    /**
-     * Create a new document
-     */
-    create: (data: Partial<T>) => Promise<T>;
-    /**
-     * Create multiple documents
-     */
-    createMany: (data: Partial<T>[]) => Promise<T[]>;
-    /**
-     * Update a document
-     */
-    update: (id: string, data: Partial<T>) => Promise<T | null>;
-    /**
-     * Delete a document
-     */
-    delete: (id: string) => Promise<boolean>;
-    /**
-     * Find documents by custom query
-     */
-    find: (query: Record<string, any>, options?: PaginationOptions) => Promise<PaginatedResult<T>>;
-    /**
-     * Count documents matching query
-     */
-    count: (query?: Record<string, any>) => Promise<number>;
-    /**
-     * Find one document
-     */
-    findOne: (query: Record<string, any>) => Promise<T | null>;
-}
-/**
- * API response format
- */
-export interface ApiResponse<T = any> {
-    success: boolean;
-    data?: T;
-    error?: string;
-    message?: string;
-    meta?: Record<string, any>;
-}
-declare global {
-    namespace Express {
-        interface Application {
-            registerApi: (routePath: string, router: any, options?: RouterOptions) => Application;
-            registerSSR: (routePath: string, component: any, options?: any) => Application;
-            start: (callback?: () => void) => any;
-            connectToDatabase: (dbOptions: DatabaseOptions) => Promise<DatabaseConnector>;
-        }
-        interface Request {
-            user?: any;
-            pagination?: PaginationOptions;
-        }
-    }
-}

package/dist/backend/types.js

@@ -1 +0,0 @@
-export {};

package/dist/batch.js

@@ -1,22 +0,0 @@
-export let isBatching = false;
-const queue = [];
-export function batchUpdates(fn) {
-    if (isBatching) {
-        queue.push(fn);
-        return;
-    }
-    isBatching = true;
-    try {
-        fn();
-        while (queue.length > 0) {
-            const nextFn = queue.shift();
-            nextFn?.();
-        }
-    }
-    finally {
-        isBatching = false;
-    }
-}
-export function getIsBatching() {
-    return isBatching;
-}

package/dist/cli/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/cli/index.js

@@ -1,215 +0,0 @@
-#!/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/dist/component.js

@@ -1,84 +0,0 @@
-import { createElement } from './jsx-runtime';
-export class Component {
-    constructor(props = {}) {
-        this.state = {};
-        this.element = null;
-        this._mounted = false;
-        this.props = props;
-    }
-    componentDidMount() {
-        // Hook for after component is mounted
-    }
-    async setState(newState) {
-        const prevState = { ...this.state };
-        this.state = { ...prevState, ...newState };
-        console.log(`${this.constructor.name} state updated:`, {
-            prev: prevState,
-            next: this.state
-        });
-        await Promise.resolve(); // Ensure state is updated before re-render
-        if (this._mounted) {
-            await this.update();
-        }
-        else {
-            await this.update();
-        }
-    }
-    _replayEvents(oldElement, newElement) {
-        const oldEvents = oldElement.__events || {};
-        Object.entries(oldEvents).forEach(([event, handler]) => {
-            newElement.addEventListener(event, handler);
-        });
-        newElement.__events = oldEvents;
-    }
-    _deepCloneWithEvents(node) {
-        const clone = node.cloneNode(false);
-        // Copy events from original element
-        const events = node.__events || {};
-        clone.__events = events;
-        Object.entries(events).forEach(([event, handler]) => {
-            clone.addEventListener(event, handler);
-        });
-        // Clone children
-        Array.from(node.childNodes).forEach(child => {
-            if (child instanceof HTMLElement) {
-                clone.appendChild(this._deepCloneWithEvents(child));
-            }
-            else {
-                clone.appendChild(child.cloneNode(true));
-            }
-        });
-        return clone;
-    }
-    async update() {
-        const vdom = this.render();
-        if (!vdom)
-            return document.createTextNode('');
-        const rendered = await createElement(vdom);
-        if (rendered instanceof HTMLElement) {
-            return this._updateElement(rendered);
-        }
-        const wrapper = document.createElement('div');
-        wrapper.appendChild(rendered);
-        return this._updateElement(wrapper);
-    }
-    async _updateElement(rendered) {
-        const newElement = this._deepCloneWithEvents(rendered);
-        newElement.__instance = this;
-        if (!this.element) {
-            this.element = newElement;
-            if (!this._mounted) {
-                this._mounted = true;
-                queueMicrotask(() => this.componentDidMount());
-            }
-        }
-        else if (this.element.parentNode) {
-            this.element.parentNode.replaceChild(newElement, this.element);
-            this.element = newElement;
-        }
-        return this.element;
-    }
-    render() {
-        throw new Error('Component must implement render() method');
-    }
-}

package/dist/components/Counter.js

@@ -1,2 +0,0 @@
-"use strict";
-// ...existing code...import { useState, useEffect } from '../index';

package/dist/context.js

@@ -1,18 +0,0 @@
-const contexts = new Map();
-let currentRender = null;
-export function createContext(defaultValue) {
-    const context = {
-        _currentValue: defaultValue,
-        Provider: function Provider({ value, children }) {
-            context._currentValue = value;
-            return children;
-        },
-        Consumer: function Consumer({ children }) {
-            return children(context._currentValue);
-        }
-    };
-    return context;
-}
-export function useContext(context) {
-    return context._currentValue;
-}