opticore-webapp 1.0.67 → 1.0.69

package/dist/index.js

@@ -1,17 +1,19 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
 // src/core/webServer.core.ts
 import * as path2 from "path";
 import process4 from "process";
 import corsOrigin from "cors";
-import { CEventNameError as eventName2, ServerListenEventError as ServerListenEventError2 } from "opticore-catch-exception-error";
-import { express } from "opticore-express";
-import { getEnvironnementValue as getEnvironnementValue2 } from "opticore-env-access";
+import express from "express";
+import chokidar from "chokidar";
+import {
+  CEvent,
+  CEventNameError as eventName2,
+  ServerListenEventError as ServerListenEventError2
+} from "opticore-catch-exception-error";
+import { getEnvironmentValue } from "opticore-env-access";
+import { requestCallsEvent } from "opticore-request-call-event";
+import { SContainer as SContainer2 } from "opticore-dependency-inject";
+import { HttpStatusCode as HttpStatusCode3 } from "opticore-http-response";
+import { TranslationLoader as TranslationLoader2 } from "opticore-translator";
 
 // src/core/handlers/eventProcess.handler.ts
 import process from "process";
@@ -449,63 +451,149 @@ var SServerStartError = (err, environmentPath) => {
 };
 
 // src/core/webServer.core.ts
-import { requestCallsEvent } from "opticore-request-call-event";
-import { SContainer as SContainer2 } from "opticore-dependency-inject";
-import { HttpStatusCode as HttpStatusCode3 } from "opticore-http-response";
-import { TranslationLoader as TranslationLoader2 } from "opticore-translator";
 var WebServerCore = class {
   serverUtility;
-  expressApp = express();
+  expressApp;
   localLanguage;
   loggerConfig;
-  routerExpressApp;
   getEnvironment;
   environmentPath;
   serverListenEvent;
+  // Existing properties
   currentRoutes = [];
   currentDependencies = [];
   server = void 0;
   errorEmitter;
-  // ✅✅✅ ÉTAT DU SERVEUR
-  serverState = "READY";
-  lastError = null;
-  // Statistiques
-  hotReloadAttempts = 0;
-  hotReloadSuccesses = 0;
-  hotReloadFailures = 0;
+  serverStatus = "STARTING";
+  serverStartTime = /* @__PURE__ */ new Date();
+  // HMR properties
+  fileWatcher = null;
+  hmrRestartPending = false;
+  hmrDebounceTimeout = null;
+  hmrRestartCount = 0;
+  lastHmrRestartTime = 0;
+  /**
+   * Creates a new WebServerCore instance.
+   *
+   * @constructor
+   * @param {WebServerConstructorInterface} paramsConstructor - Configuration parameters
+   *
+   * @param {express.Application} paramsConstructor.app - Express application instance
+   * @param {LoggerCore} paramsConstructor.loggerConfig - Logger configuration
+   * @param {string} paramsConstructor.environmentPath - Path to environment file
+   * @param {string} paramsConstructor.localLanguage - Default language for translations
+   * @param {CorsOptions} paramsConstructor.corsOriginOptions - CORS configuration
+   *
+   * @returns {WebServerCore} New WebServerCore instance
+   *
+   * @throws {Error} If environment file cannot be loaded
+   *
+   * @example
+   * ```typescript
+   * const server = new WebServerCore({
+   *   app: express(),
+   *   loggerConfig: new LoggerCore(config),
+   *   environmentPath: ".env",
+   *   localLanguage: "fr",
+   *   corsOriginOptions: { origin: "http://localhost:3000" }
+   * });
+   * ```
+   */
   constructor(paramsConstructor) {
-    this.getEnvironment = getEnvironnementValue2(paramsConstructor.environmentPath);
-    this.routerExpressApp = paramsConstructor.app;
+    this.getEnvironment = getEnvironmentValue(paramsConstructor.environmentPath);
     this.loggerConfig = paramsConstructor.loggerConfig;
     this.localLanguage = paramsConstructor.localLanguage;
     this.environmentPath = paramsConstructor.environmentPath;
+    this.expressApp = express();
+    this.serverListenEvent = new ServerListenEventError2(paramsConstructor.localLanguage);
     this.expressApp.use(express.json());
     this.expressApp.use(express.raw());
     this.expressApp.use(express.text());
     this.expressApp.use(express.urlencoded({ extended: true }));
     this.expressApp.use(corsOrigin(paramsConstructor.corsOriginOptions));
-    this.serverListenEvent = new ServerListenEventError2(paramsConstructor.localLanguage);
     this.serverUtility = new CoreService(paramsConstructor.localLanguage, paramsConstructor.environmentPath);
-    this.setupSignalHandlers();
-    this.setupIPCHandlers();
+    this.serverStatus = "STARTING";
+    this.serverStartTime = /* @__PURE__ */ new Date();
+    this.setupProcessEventListeners();
   }
+  /**
+   * Starts the HTTP server and initializes all components including HMR if enabled.
+   *
+   * @method onStartServer
+   * @public
+   *
+   * @param {TFeatureRoutes[]} routers - Array of feature routes to register
+   * @param {(env: IEnvVariables) => void} [databaseCallback] - Optional database connection callback
+   * @param {TDependency[]} [dependenciesProvider] - Optional dependency injection providers
+   *
+   * @returns {serverWebApp | undefined} HTTP server instance or undefined if startup fails
+   *
+   * @throws {ServerListenEventError} If port/host configuration is invalid
+   * @throws {Error} If server initialization fails
+   *
+   * @fires WebServerCore#startHttpServer - When server successfully starts
+   * @fires WebServerCore#startHMR - When HMR is started (if enabled)
+   * @fires WebServerCore#serverError - When server fails to start
+   *
+   * @example
+   * ```typescript
+   * const server = app.onStartServer(
+   *   routes,
+   *   (env) => connectToDatabase(env),
+   *   dependencies
+   * );
+   *
+   * if (server) {
+   *   console.log("Server started successfully");
+   * }
+   * ```
+   */
   onStartServer(routers, databaseCallback, dependenciesProvider) {
+    try {
+      loaderTranslationFile(this.localLanguage);
+      this.currentRoutes = routers;
+      this.currentDependencies = dependenciesProvider || [];
+      this.serverStartTime = /* @__PURE__ */ new Date();
+      this.serverStatus = "STARTING";
+      if (!this.validateServerParameters()) {
+        return void 0;
+      }
+      const server = this.startHttpServer(databaseCallback);
+      if (this.getEnvironment.hmrEnabled) {
+        this.startHMR();
+      }
+      return server;
+    } catch (error) {
+      this.handleStartupError(error);
+    }
+  }
+  /**
+   * Validates server configuration parameters.
+   *
+   * @method validateServerParameters
+   * @private
+   *
+   * @returns {boolean} True if all parameters are valid, false otherwise
+   *
+   * @remarks
+   * Validates:
+   * - Port number is valid and positive
+   * - Host is not empty
+   * - Local language is specified
+   * - HMR configuration (if enabled)
+   */
+  validateServerParameters() {
     loaderTranslationFile(this.localLanguage);
-    this.currentRoutes = routers;
-    this.currentDependencies = dependenciesProvider || [];
-    if (this.getEnvironment.appPort === "" && Number(this.getEnvironment.appPort) === 0) {
-      this.serverListenEvent.hostPortUndefined(Number(this.getEnvironment.appPort));
-      return void 0;
+    const port = Number(this.getEnvironment.appPort);
+    if (isNaN(port) || port <= 0) {
+      this.serverListenEvent.portUndefined();
+      return false;
     }
-    if (this.getEnvironment.appHost === "") {
+    if (!this.getEnvironment.appHost || this.getEnvironment.appHost.trim() === "") {
       this.serverListenEvent.hostUndefined(this.getEnvironment.appHost);
-      return void 0;
+      return false;
     }
-    if (Number(this.getEnvironment.appPort) === 0) {
-      this.serverListenEvent.portUndefined();
-      return void 0;
-    }
-    if (this.localLanguage === "") {
+    if (!this.localLanguage || this.localLanguage.trim() === "") {
       SLogger(this.localLanguage).logger.error({
         message: TranslationLoader2.t("noDefaultLocalLang", this.localLanguage),
         title: TranslationLoader2.t("noLocalLang", this.localLanguage),
@@ -513,75 +601,225 @@ var WebServerCore = class {
         stackTrace: void 0,
         httpCodeValue: HttpStatusCode3.NOT_FOUND
       });
-      return void 0;
+      return false;
     }
-    this.server = this.expressApp.listen(
-      Number(this.getEnvironment.appPort),
-      this.getEnvironment.appHost,
-      () => {
+    if (this.getEnvironment.hmrEnabled) {
+      if (!this.getEnvironment.hmrWatchPatterns || this.getEnvironment.hmrWatchPatterns.length === 0) {
+        SLogger(this.localLanguage).logger.warn({
+          title: TranslationLoader2.t("HMR_CONFIG_WARNING", this.localLanguage),
+          message: "HMR enabled but no watch patterns defined"
+        });
+      }
+    }
+    return true;
+  }
+  /**
+   * Starts the HTTP server and sets up event listeners.
+   *
+   * @method startHttpServer
+   * @private
+   *
+   * @param {(env: IEnvVariables) => void} [databaseCallback] - Database connection callback
+   *
+   * @returns {serverWebApp | undefined} HTTP server instance or undefined if startup fails
+   *
+   * @throws {Error} If server fails to start
+   */
+  startHttpServer(databaseCallback) {
+    try {
+      loaderTranslationFile(this.localLanguage);
+      const port = Number(this.getEnvironment.appPort);
+      const host = this.getEnvironment.appHost;
+      this.server = this.expressApp.listen(port, host, () => {
         try {
+          this.configureServerComponents(databaseCallback);
+          this.serverStatus = "READY";
           SLogger(this.localLanguage).logger.info({
-            message: TranslationLoader2.t("HOT_RELOAD_READY", this.localLanguage),
-            title: TranslationLoader2.t("HOT_RELOAD", this.localLanguage)
+            title: TranslationLoader2.t("SERVER_RUNNING_TITLE", this.localLanguage),
+            message: TranslationLoader2.t("SERVER_RUNNING_AT", this.localLanguage, {
+              server: `${host}:${port}`,
+              hmrEnabled: this.getEnvironment.hmrEnabled ? "with HMR" : "without HMR"
+            })
           });
-          if (databaseCallback) {
-            databaseCallback(this.getEnvironment);
-          }
-          new SContainer2(this.localLanguage, this.currentDependencies);
-          this.expressApp.use(express.static(path2.join(process4.cwd(), "public/template")));
-          this.registerRoutes(this.currentRoutes);
-          this.setupErrorHandling();
-          this.setupServerEvents();
-          this.serverState = "READY";
-          this.infoWebApp();
-          this.notifyServerReady();
         } catch (err) {
-          SLogger(this.localLanguage).logger.error({
-            title: TranslationLoader2.t("STARTUP_ERROR", this.localLanguage),
-            message: err.message,
-            errorType: err.code,
-            stackTrace: err.stackTrace,
-            httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
-          });
-          SServerStartError(err, this.environmentPath);
+          this.handleServerConfigurationError(err);
+        }
+      });
+      this.setupServerEventListeners();
+      return this.server;
+    } catch (error) {
+      this.serverListenEvent.onEventError(
+        new Error(TranslationLoader2.t(
+          "HTTP_SERVER_FAILED",
+          this.localLanguage,
+          { errorMessage: error.message }
+        ))
+      );
+    }
+  }
+  /**
+   * Configures server components (database, dependencies, routes, etc.).
+   *
+   * @method configureServerComponents
+   * @private
+   *
+   * @param {(env: IEnvVariables) => void} [databaseCallback] - Database connection callback
+   *
+   * @returns {void}
+   *
+   * @throws {Error} If component configuration fails
+   */
+  configureServerComponents(databaseCallback) {
+    try {
+      loaderTranslationFile(this.localLanguage);
+      if (databaseCallback && typeof databaseCallback === "function") {
+        try {
+          databaseCallback(this.getEnvironment);
+        } catch (dbError) {
+          this.serverListenEvent.listenerError(
+            new Error(TranslationLoader2.t("DB_CON_FAILED", this.localLanguage, { dbErrorMessage: dbError.message }))
+          );
         }
       }
-    );
-    return this.server;
+      try {
+        new SContainer2(this.localLanguage, this.currentDependencies);
+      } catch (depError) {
+        this.serverListenEvent.listenerError(
+          new Error(TranslationLoader2.t("DEPENDENCY_INJECTION_FAILED", this.localLanguage, { depErrorMessage: depError.message }))
+        );
+      }
+      this.expressApp.use(express.static(path2.join(process4.cwd(), "public/template")));
+      this.registerRoutes(this.currentRoutes);
+      this.setupErrorHandling();
+      this.infoWebApp();
+    } catch (error) {
+      this.serverListenEvent.listenerError(
+        new Error(TranslationLoader2.t("SERVER_COMPONENT_CONFIG_FAILED", this.localLanguage, { errorMessage: error.message }))
+      );
+      throw error;
+    }
   }
   /**
-   * ✅✅✅ Configuration de la gestion d'erreurs
+   * Handles server configuration errors.
+   *
+   * @method handleServerConfigurationError
+   * @private
+   *
+   * @param {any} err - The error that occurred
+   *
+   * @returns {void}
    */
-  setupErrorHandling() {
-    SLogger(this.localLanguage).logger.info({
-      title: TranslationLoader2.t("SETTING_UP", this.localLanguage),
-      message: TranslationLoader2.t("SETTING_UP_ERROR", this.localLanguage)
-    });
-    this.errorEmitter = eventProcessHandler(this.localLanguage, this.expressApp);
-    if (this.errorEmitter) {
-      this.errorEmitter.on("transformError", (error) => {
-        SLogger(this.localLanguage).logger.info({
-          title: TranslationLoader2.t("", this.localLanguage),
-          message: TranslationLoader2.t("", this.localLanguage)
-        });
-        this.lastError = error;
-        this.serverState = "BLOCKED";
-        this.notifyWatcherBlockedByError(error);
-      });
-      this.errorEmitter.on("error", (error) => {
-        SLogger(this.localLanguage).logger.info({
-          title: TranslationLoader2.t("ERROR_EMITTED", this.localLanguage),
-          message: `Error emitted: ${error.message}`
-        });
-      });
+  handleServerConfigurationError(err) {
+    loaderTranslationFile(this.localLanguage);
+    this.serverStatus = "ERROR";
+    this.serverListenEvent.onEventError(err);
+    try {
+      SServerStartError(err, this.environmentPath);
+    } catch (startError) {
+      this.serverListenEvent.listenerError(startError);
     }
-    SLogger(this.localLanguage).logger.info({
-      title: TranslationLoader2.t("ERROR_HANDLING", this.localLanguage),
-      message: TranslationLoader2.t("ERROR_HANDLING_CONFIGURED", this.localLanguage)
+  }
+  /**
+   * Handles general startup errors.
+   *
+   * @method handleStartupError
+   * @private
+   *
+   * @param {any} error - The startup error
+   *
+   * @returns {void}
+   */
+  handleStartupError(error) {
+    loaderTranslationFile(this.localLanguage);
+    this.serverStatus = "ERROR";
+    this.serverListenEvent.listenerError(error);
+    SLogger(this.localLanguage).logger.error({
+      title: TranslationLoader2.t("GLOBAL_STARTUP_ERROR", this.localLanguage),
+      message: error.message,
+      errorType: error.name || "StartupError",
+      stackTrace: error.stack,
+      httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
+    });
+  }
+  /**
+   * Sets up Node.js process event listeners.
+   *
+   * @method setupProcessEventListeners
+   * @private
+   *
+   * @returns {void}
+   *
+   * @remarks
+   * Listens for:
+   * - Process exit events
+   * - Uncaught exceptions
+   * - Unhandled rejections
+   * - System signals (SIGINT, SIGTERM)
+   */
+  setupProcessEventListeners() {
+    loaderTranslationFile(this.localLanguage);
+    process4.on(CEvent.beforeExit, (code) => {
+      this.serverListenEvent.processBeforeExit(code);
+    });
+    process4.on(CEvent.disconnect, () => {
+      this.serverListenEvent.processDisconnected();
+    });
+    process4.on(CEvent.exit, (code) => {
+      this.serverListenEvent.exited(code);
+    });
+    process4.on(CEvent.message, (message) => {
+      this.serverListenEvent.message(message);
+    });
+    process4.on(CEvent.multipleResolves, (type, promise, reason) => {
+      this.serverListenEvent.multipleResolves(type, promise, reason);
+    });
+    process4.on(CEvent.rejectionHandled, (promise) => {
+      this.serverListenEvent.promiseRejectionHandled(promise);
+    });
+    process4.on(CEvent.uncaughtException, (error) => {
+      this.serverListenEvent.uncaughtException(error);
+    });
+    process4.on(CEvent.uncaughtExceptionMonitor, (error) => {
+      this.serverListenEvent.uncaughtExceptionMonitor(error);
+    });
+    process4.on(CEvent.unhandledRejection, (reason, promise) => {
+      this.serverListenEvent.unhandledRejection(reason, promise);
+    });
+    process4.on(CEvent.warning, (warning) => {
+      this.serverListenEvent.warning(warning);
+    });
+    process4.on(CEvent.sigint, () => {
+      this.serverListenEvent.processInterrupted();
+    });
+    process4.on(CEvent.sigterm, (signal) => {
+      this.serverListenEvent.sigtermSignalReceived(signal);
     });
   }
-  setupServerEvents() {
-    if (!this.server) return;
+  /**
+   * Sets up HTTP server event listeners.
+   *
+   * @method setupServerEventListeners
+   * @private
+   *
+   * @returns {void}
+   *
+   * @remarks
+   * Configures listeners for:
+   * - Server errors
+   * - Connection closing
+   * - Connection dropping
+   * - HTTP requests (for logging)
+   *
+   * @listens Server#error - Server error events
+   * @listens Server#close - Server closing events
+   * @listens Server#drop - Connection drop events
+   * @listens Server#request - HTTP request events
+   */
+  setupServerEventListeners() {
+    loaderTranslationFile(this.localLanguage);
+    if (!this.server) {
+      return;
+    }
     this.server.on(eventName2.error, (err) => {
       this.serverListenEvent.onEventError(err);
     });
@@ -603,270 +841,624 @@ var WebServerCore = class {
       );
     });
   }
-  notifyServerReady() {
-    setTimeout(() => {
-      if (process4.send) {
-        process4.send({
-          type: "SERVER_READY",
-          timestamp: Date.now(),
-          port: Number(this.getEnvironment.appPort),
-          host: this.getEnvironment.appHost,
-          message: "Server ready for hot reload"
+  /**
+   * Sets up error handling middleware and event emitters.
+   *
+   * @method setupErrorHandling
+   * @private
+   *
+   * @returns {void}
+   */
+  setupErrorHandling() {
+    loaderTranslationFile(this.localLanguage);
+    SLogger(this.localLanguage).logger.info({
+      title: TranslationLoader2.t("SETTING_UP", this.localLanguage),
+      message: TranslationLoader2.t("SETTING_UP_ERROR", this.localLanguage)
+    });
+    this.errorEmitter = eventProcessHandler(this.localLanguage, this.expressApp);
+    if (this.errorEmitter) {
+      this.expressApp.use((err, req, res, next) => {
+        this.serverListenEvent.expressErrorHandlingMiddleware(
+          this.errorEmitter,
+          err,
+          req,
+          res,
+          next
+        );
+      });
+      this.errorEmitter.on("transformError", (error) => {
+        this.serverListenEvent.listenerError(error);
+      });
+      this.errorEmitter.on("error", (error) => {
+        this.serverListenEvent.listenerError(error);
+      });
+      this.errorEmitter.on("hotReload", (data) => {
+        SLogger(this.localLanguage).logger.info({
+          title: TranslationLoader2.t("HOT_RELOAD_EVENT", this.localLanguage),
+          message: `Hot reload triggered for ${data.file}`
+        });
+      });
+    }
+    SLogger(this.localLanguage).logger.info({
+      title: TranslationLoader2.t("ERROR_HANDLING", this.localLanguage),
+      message: TranslationLoader2.t("ERROR_HANDLING_CONFIGURED", this.localLanguage)
+    });
+  }
+  /**
+   * Registers routes with the Express application.
+   *
+   * @method registerRoutes
+   * @private
+   *
+   * @param {any[]} allFeatureRoutes - Array of feature routes to register
+   *
+   * @returns {void}
+   */
+  registerRoutes(allFeatureRoutes) {
+    allFeatureRoutes.forEach((router) => {
+      if (router.routes) {
+        router.routes.forEach((route) => {
+          this.expressApp.use(route.path, route.handler);
         });
       }
-    }, 100);
+    });
+  }
+  /**
+   * Displays server information.
+   *
+   * @method infoWebApp
+   * @private
+   *
+   * @returns {void}
+   */
+  infoWebApp() {
+    loaderTranslationFile(this.localLanguage);
+    this.serverUtility.infoServer(
+      this.getEnvironment.appHost,
+      Number(this.getEnvironment.appPort)
+    );
   }
-  setupSignalHandlers() {
-    process4.on("SIGHUP", async () => {
-      if (this.serverState === "READY") {
+  /**
+   * Starts the Hot Module Replacement (HMR) file watching system.
+   *
+   * @method startHMR
+   * @private
+   *
+   * @returns {void}
+   *
+   * @remarks
+   * Configures file watcher based on environment variables:
+   * - HMR_ENABLED: Enable/disable HMR
+   * - HMR_WATCH_PATTERNS: Files to watch
+   * - HMR_IGNORE_PATTERNS: Files to ignore
+   *
+   * @throws {Error} If HMR configuration is invalid
+   */
+  startHMR() {
+    try {
+      loaderTranslationFile(this.localLanguage);
+      const hmrConfig = this.getEnvironment;
+      if (!hmrConfig.hmrEnabled) {
         SLogger(this.localLanguage).logger.info({
-          title: TranslationLoader2.t("SIGHUP", this.localLanguage),
-          message: TranslationLoader2.t("RECEIVED_SIGHUP", this.localLanguage)
+          title: TranslationLoader2.t("HMR_DISABLED", this.localLanguage),
+          message: "HMR is disabled in configuration"
         });
-        await this.performTrueHotReload();
+        return;
       }
-    });
-    process4.on("SIGTERM", () => {
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("SIGHUP", this.localLanguage),
-        message: TranslationLoader2.t("RECEIVED_SIGHUP", this.localLanguage)
+      if (!hmrConfig.hmrWatchPatterns || hmrConfig.hmrWatchPatterns.length === 0) {
+        SLogger(this.localLanguage).logger.error({
+          title: TranslationLoader2.t("HMR_WATCH_PATTERNS_MISSING", this.localLanguage),
+          message: "No watch patterns defined for HMR",
+          errorType: "HMR Configuration Error",
+          httpCodeValue: HttpStatusCode3.BAD_REQUEST
+        });
+        return;
+      }
+      const watchPatterns = hmrConfig.hmrWatchPatterns;
+      const ignorePatterns = hmrConfig.hmrIgnorePatterns || [
+        "node_modules/**",
+        "dist/**",
+        "build/**",
+        "*.log",
+        ".git/**"
+      ];
+      const allPatterns = [
+        ...watchPatterns,
+        ...ignorePatterns.map((pattern) => `!${pattern}`)
+      ];
+      this.fileWatcher = chokidar.watch(allPatterns, {
+        ignored: /(^|[/\\])\../,
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+          stabilityThreshold: 300,
+          pollInterval: 100
+        },
+        cwd: process4.cwd(),
+        depth: 10
       });
-      this.shutdown();
-    });
-    process4.on("SIGINT", () => {
+      this.fileWatcher.on("ready", () => this.onHMRWatcherReady(watchPatterns, ignorePatterns)).on("change", (filePath) => this.handleFileChange(filePath)).on("add", (filePath) => this.handleFileChange(filePath, "added")).on("unlink", (filePath) => this.handleFileChange(filePath, "deleted")).on("error", (error) => this.onHMRWatcherError(error));
+      this.hmrRestartCount = 0;
+      this.lastHmrRestartTime = Date.now();
       SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("SIGINT", this.localLanguage),
-        message: TranslationLoader2.t("RECEIVED_SIGINT", this.localLanguage)
+        title: TranslationLoader2.t("HMR_STARTED", this.localLanguage),
+        message: TranslationLoader2.t("HMR_MONITORING_STARTED", this.localLanguage)
       });
-      this.shutdown();
-    });
-  }
-  setupIPCHandlers() {
-    if (!process4.send) {
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("IPC", this.localLanguage),
-        message: TranslationLoader2.t("IPC_NOT_AVAILABLE", this.localLanguage)
+    } catch (error) {
+      SLogger(this.localLanguage).logger.error({
+        title: TranslationLoader2.t("HMR_START_FAILED", this.localLanguage),
+        message: error.message,
+        errorType: "HMR Error",
+        stackTrace: error.stack
       });
-      return;
     }
-    SLogger(this.localLanguage).logger.info({
-      title: TranslationLoader2.t("IPC_READY", this.localLanguage),
-      message: TranslationLoader2.t("IPC_READY_HOT_RELOAD", this.localLanguage)
-    });
-    process4.on("message", async (message) => {
-      if (message.type === "HOT_RELOAD_REQUEST") {
-        if (this.serverState === "BLOCKED") {
-          SLogger(this.localLanguage).logger.info({
-            title: TranslationLoader2.t("BLOCKED", this.localLanguage),
-            message: TranslationLoader2.t("BLOCKED_STATE", this.localLanguage)
-          });
-          return;
-        }
-        if (this.serverState === "READY") {
-          await this.performTrueHotReload();
-        }
-      }
-    });
   }
   /**
-   * ✅✅✅ HOT RELOAD avec gestion d'état stricte
+   * Handles file change events with debouncing.
+   *
+   * @method handleFileChange
+   * @private
+   *
+   * @param {string} filePath - Path of the changed file
+   * @param {string} [action="modified"] - Type of file change (modified/added/deleted)
+   *
+   * @returns {void}
+   *
+   * @remarks
+   * Uses debouncing to prevent multiple rapid reloads.
+   * Debounce time configurable via HMR_DEBOUNCE_MS environment variable.
    */
-  async performTrueHotReload() {
-    this.serverState = "RELOADING";
-    this.hotReloadAttempts++;
-    const startTime = Date.now();
+  handleFileChange(filePath, action = "modified") {
+    const debounceMs = this.getEnvironment.hmrDebounceMs || 500;
+    if (this.hmrDebounceTimeout) {
+      clearTimeout(this.hmrDebounceTimeout);
+    }
+    this.hmrDebounceTimeout = setTimeout(async () => {
+      await this.triggerHotReload(filePath, action);
+    }, debounceMs);
     SLogger(this.localLanguage).logger.info({
-      title: TranslationLoader2.t("RELOAD_STARTING", this.localLanguage),
-      message: TranslationLoader2.t("HOT_RELOAD_ATTEMPTED", this.localLanguage, { hotReloadAttempts: this.hotReloadAttempts })
+      title: TranslationLoader2.t("FILE_CHANGE_DETECTED", this.localLanguage),
+      message: `File ${action}: ${filePath}`
     });
+  }
+  /**
+   * Triggers a hot reload operation.
+   *
+   * @method triggerHotReload
+   * @private
+   *
+   * @param {string} filePath - Path of the changed file
+   * @param {string} action - Type of file change
+   *
+   * @returns {Promise<void>}
+   *
+   * @remarks
+   * - Checks if reload is already in progress
+   * - Validates restart limits
+   * - Performs appropriate reload actions based on file type
+   * - Emits hotReload event
+   */
+  async triggerHotReload(filePath, action) {
+    if (this.hmrRestartPending) {
+      return;
+    }
+    if (!this.canProceedWithHMRRestart()) {
+      return;
+    }
+    this.hmrRestartPending = true;
+    this.hmrRestartCount++;
+    this.lastHmrRestartTime = Date.now();
     try {
-      const clearedModules = this.clearApplicationModulesCache();
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("APP_MODULES_CLEARED", this.localLanguage),
-        message: TranslationLoader2.t("CLEARED_MODULES", this.localLanguage, { clearedModules })
-      });
-      this.reloadConfigurations();
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("APP_MODULES_CLEARED", this.localLanguage),
-        message: TranslationLoader2.t("CLEARED_MODULES", this.localLanguage, { hotReloadAttempts: this.hotReloadAttempts })
-      });
-      this.reloadDependencies();
+      loaderTranslationFile(this.localLanguage);
       SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("DEPENDENCIES", this.localLanguage),
-        message: TranslationLoader2.t("RELOAD_DEPENDENCIES", this.localLanguage)
+        title: TranslationLoader2.t("HOT_RELOAD_STARTING", this.localLanguage),
+        message: TranslationLoader2.t("RELOADING_APPLICATION", this.localLanguage, {
+          file: filePath,
+          action
+        })
       });
-      const duration = Date.now() - startTime;
-      this.hotReloadSuccesses++;
-      this.serverState = "READY";
-      this.lastError = null;
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("RELOAD_SUCCESS", this.localLanguage),
-        message: TranslationLoader2.t("HOT_RELOAD_SUCCESS", this.localLanguage, { duration })
+      if (this.errorEmitter) {
+        this.errorEmitter.emit("hotReload", {
+          file: filePath,
+          action,
+          timestamp: /* @__PURE__ */ new Date(),
+          restartCount: this.hmrRestartCount
+        });
+      }
+      await this.performHotReloadActions(filePath);
+      SLogger(this.localLanguage).logger.success({
+        title: TranslationLoader2.t("HOT_RELOAD_COMPLETE", this.localLanguage),
+        message: TranslationLoader2.t("APPLICATION_RELOADED", this.localLanguage, {
+          file: filePath,
+          restartCount: this.hmrRestartCount,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
       });
-      this.notifyWatcherReloadSuccess(duration);
     } catch (error) {
-      this.hotReloadFailures++;
-      const duration = Date.now() - startTime;
-      SLogger(this.localLanguage).logger.info({
-        title: TranslationLoader2.t("RELOAD_FAILED", this.localLanguage),
-        message: TranslationLoader2.t("HOT_RELOAD_FAILED", this.localLanguage, { duration, errorMessage: error.message })
+      SLogger(this.localLanguage).logger.error({
+        title: TranslationLoader2.t("HOT_RELOAD_FAILED", this.localLanguage),
+        message: error.message,
+        errorType: "HotReloadError",
+        stackTrace: error.stack,
+        httpCodeValue: HttpStatusCode3.INTERNAL_SERVER_ERROR
       });
-      const isTransformError = error?.name === "TransformError" || error?.message?.includes("Transform failed") || error?.message?.includes("esbuild");
-      if (isTransformError) {
-        this.lastError = error;
-        this.serverState = "BLOCKED";
-        this.notifyWatcherBlockedByError(error);
-      } else {
-        this.serverState = "BLOCKED";
-        this.notifyWatcherReloadError(error);
-      }
+    } finally {
+      this.hmrRestartPending = false;
     }
   }
   /**
-   * Nettoie le cache des modules applicatifs
+   * Performs appropriate hot reload actions based on file type.
+   *
+   * @method performHotReloadActions
+   * @private
+   *
+   * @param {string} filePath - Path of the changed file
+   *
+   * @returns {Promise<void>}
+   *
+   * @remarks
+   * Different actions for different file types:
+   * - .json/.env: Reload translations
+   * - routes/controller files: Reload routes
+   * - config/.env files: Reload dependencies
    */
-  clearApplicationModulesCache() {
-    const baseDirs = [
-      path2.join(process4.cwd(), "src"),
-      path2.join(process4.cwd(), "dist")
-    ];
-    let clearedCount = 0;
-    for (const key in __require.cache) {
-      const isApplicationModule = baseDirs.some((dir) => key.startsWith(dir));
-      const isNodeModule = key.includes("node_modules");
-      const isJsonFile = key.endsWith(".json");
-      if (isApplicationModule && !isNodeModule && !isJsonFile) {
-        delete __require.cache[key];
-        clearedCount++;
-      }
+  async performHotReloadActions(filePath) {
+    if (filePath.includes(".json") || filePath.endsWith(".env")) {
+      loaderTranslationFile(this.localLanguage);
+    }
+    if (filePath.includes("routes") || filePath.includes("controller")) {
+      await this.reloadRoutes();
+    }
+    if (filePath.includes("config") || filePath.includes(".env")) {
+      await this.reloadDependencies();
     }
-    return clearedCount;
   }
-  reloadConfigurations() {
+  /**
+   * Reloads routes dynamically.
+   *
+   * @method reloadRoutes
+   * @private
+   *
+   * @returns {Promise<void>}
+   *
+   * @throws {Error} If route reloading fails
+   *
+   * @remarks
+   * This method should be implemented based on your architecture.
+   * It should reload route modules from the filesystem.
+   */
+  async reloadRoutes() {
     try {
-      const newEnv = getEnvironnementValue2(this.environmentPath);
-      Object.keys(newEnv).forEach((key) => {
-        this.getEnvironment[key] = newEnv[key];
+      SLogger(this.localLanguage).logger.info({
+        title: TranslationLoader2.t("ROUTES_RELOADED", this.localLanguage),
+        message: "Routes dynamically reloaded"
       });
-      loaderTranslationFile(this.localLanguage);
     } catch (error) {
-      throw new Error(`Configuration reload failed: ${error.message}`);
+      throw new Error(`Route reload failed: ${error.message}`);
     }
   }
-  reloadDependencies() {
+  /**
+   * Reloads dependencies dynamically.
+   *
+   * @method reloadDependencies
+   * @private
+   *
+   * @returns {Promise<void>}
+   *
+   * @throws {Error} If dependency reloading fails
+   */
+  async reloadDependencies() {
     try {
-      new SContainer2(this.localLanguage, this.currentDependencies);
-      const container = dependenciesContainerProvider(this.localLanguage);
-      if (!container) {
-        throw new Error("Dependency container is not available");
+      if (this.currentDependencies.length > 0) {
+        new SContainer2(this.localLanguage, this.currentDependencies);
+        SLogger(this.localLanguage).logger.info({
+          title: TranslationLoader2.t("DEPENDENCIES_RELOADED", this.localLanguage),
+          message: "Dependencies reloaded"
+        });
       }
     } catch (error) {
       throw new Error(`Dependency reload failed: ${error.message}`);
     }
   }
   /**
-   * ✅✅✅ Notifier le watcher : SUCCÈS
+   * Checks if HMR restart can proceed based on configuration limits.
+   *
+   * @method canProceedWithHMRRestart
+   * @private
+   *
+   * @returns {boolean} True if restart can proceed, false otherwise
+   *
+   * @remarks
+   * Checks:
+   * - Auto-restart enabled/disabled
+   * - Maximum restarts per minute limit
    */
-  notifyWatcherReloadSuccess(duration) {
-    if (process4.send && process4.env.WATCHER_MODE === "true") {
-      process4.send({
-        type: "HOT_RELOAD_SUCCESS",
-        timestamp: Date.now(),
-        duration,
-        serverState: this.serverState,
-        message: "Code reloaded successfully"
+  canProceedWithHMRRestart() {
+    const hmrConfig = this.getEnvironment;
+    if (!hmrConfig.hmrAutoRestarts) {
+      SLogger(this.localLanguage).logger.warn({
+        title: TranslationLoader2.t("HMR_AUTO_RESTART_DISABLED", this.localLanguage),
+        message: "HMR auto-restart disabled"
       });
+      return false;
     }
-  }
-  /**
-   * ✅✅✅ Notifier le watcher : BLOQUÉ PAR ERREUR TRANSFORM
-   */
-  notifyWatcherBlockedByError(error) {
-    if (process4.send && process4.env.WATCHER_MODE === "true") {
-      const errorDetails = this.parseTransformError(error);
-      process4.send({
-        type: "HOT_RELOAD_BLOCKED_BY_ERROR",
-        timestamp: Date.now(),
-        serverState: this.serverState,
-        error: {
-          message: error.message,
-          errorType: error.name || "TransformError",
-          file: errorDetails.file,
-          line: errorDetails.line,
-          column: errorDetails.column,
-          detail: errorDetails.errorDetail,
-          tool: errorDetails.tool
-        }
+    const maxRestarts = hmrConfig.hmrMaxRestarts || 5;
+    const now = Date.now();
+    const oneMinuteAgo = now - 6e4;
+    if (this.lastHmrRestartTime < oneMinuteAgo) {
+      this.hmrRestartCount = 0;
+    }
+    if (this.hmrRestartCount >= maxRestarts) {
+      const nextReset = Math.ceil((this.lastHmrRestartTime + 6e4 - now) / 1e3);
+      SLogger(this.localLanguage).logger.error({
+        title: TranslationLoader2.t("HMR_RESTART_LIMIT_EXCEEDED", this.localLanguage),
+        message: TranslationLoader2.t("HMR_RESTART_LIMIT_MESSAGE", this.localLanguage, {
+          max: maxRestarts,
+          nextReset
+        })
       });
+      return false;
     }
+    return true;
   }
   /**
-   * ✅✅✅ Notifier le watcher : ERREUR GÉNÉRIQUE
+   * Called when the HMR watcher is ready.
+   *
+   * @method onHMRWatcherReady
+   * @private
+   *
+   * @param {string[]} watchPatterns - Patterns being watched
+   * @param {string[]} ignorePatterns - Patterns being ignored
+   *
+   * @returns {void}
    */
-  notifyWatcherReloadError(error) {
-    if (process4.send && process4.env.WATCHER_MODE === "true") {
-      process4.send({
-        type: "HOT_RELOAD_ERROR",
-        timestamp: Date.now(),
-        serverState: this.serverState,
-        error: error.message,
-        errorType: error.name || "UNKNOWN_ERROR"
-      });
-    }
+  onHMRWatcherReady(watchPatterns, ignorePatterns) {
+    SLogger(this.localLanguage).logger.info({
+      title: TranslationLoader2.t("HMR_WATCHER_READY", this.localLanguage),
+      message: TranslationLoader2.t("HMR_WATCHING_DETAILS", this.localLanguage, {
+        watchCount: watchPatterns,
+        ignoreCount: ignorePatterns
+      })
+    });
   }
   /**
-   * ✅✅✅ Parser les détails d'une TransformError
+   * Handles HMR watcher errors.
+   *
+   * @method onHMRWatcherError
+   * @private
+   *
+   * @param {Error} error - The watcher error
+   *
+   * @returns {void}
    */
-  parseTransformError(error) {
-    const errorMessage = error.message || String(error);
-    let tool = "Unknown";
-    if (errorMessage.includes("esbuild")) tool = "esbuild";
-    if (errorMessage.includes("webpack")) tool = "webpack";
-    const fileMatch = errorMessage.match(/([^:\s]+\.(?:ts|js|tsx|jsx)):(\d+):(\d+):/);
-    const file = fileMatch ? fileMatch[1] : null;
-    const line = fileMatch ? parseInt(fileMatch[2], 10) : null;
-    const column = fileMatch ? parseInt(fileMatch[3], 10) : null;
-    const errorDetailMatch = errorMessage.match(/ERROR:\s*(.+?)(?:\n|$)/);
-    const errorDetail = errorDetailMatch ? errorDetailMatch[1].trim() : null;
-    return {
-      message: errorMessage,
-      file,
-      line,
-      column,
-      errorDetail,
-      tool
-    };
-  }
-  registerRoutes(allFeatureRoutes) {
-    allFeatureRoutes.forEach((router) => {
-      if (router.routes) {
-        router.routes.forEach((route) => {
-          this.expressApp.use(route.path, route.handler);
-        });
-      }
+  onHMRWatcherError(error) {
+    SLogger(this.localLanguage).logger.error({
+      title: TranslationLoader2.t("HMR_WATCHER_ERROR", this.localLanguage),
+      message: error.message,
+      errorType: "FileWatcherError",
+      stackTrace: error.stack
     });
   }
-  infoWebApp() {
-    this.serverUtility.infoServer(
-      this.getEnvironment.appHost,
-      Number(this.getEnvironment.appPort)
-    );
+  /**
+   * Stops the HMR system.
+   *
+   * @method stopHMR
+   * @private
+   *
+   * @returns {void}
+   */
+  stopHMR() {
+    if (this.fileWatcher) {
+      this.fileWatcher.close();
+      this.fileWatcher = null;
+    }
+    if (this.hmrDebounceTimeout) {
+      clearTimeout(this.hmrDebounceTimeout);
+      this.hmrDebounceTimeout = null;
+    }
+    SLogger(this.localLanguage).logger.info({
+      title: TranslationLoader2.t("HMR_STOPPED", this.localLanguage),
+      message: TranslationLoader2.t("HMR_MONITORING_STOPPED", this.localLanguage)
+    });
   }
-  shutdown() {
+  /**
+   * Stops the server and HMR system cleanly.
+   *
+   * @method onStopServer
+   * @public
+   *
+   * @returns {void}
+   */
+  onStopServer() {
+    this.stopHMR();
     if (this.server) {
       this.server.close(() => {
         SLogger(this.localLanguage).logger.info({
-          title: TranslationLoader2.t("CLOSED", this.localLanguage),
-          message: TranslationLoader2.t("SERVER_CLOSED", this.localLanguage)
+          title: TranslationLoader2.t("SERVER_STOPPED", this.localLanguage),
+          message: "Server stopped cleanly"
         });
-        process4.exit(0);
       });
-      setTimeout(() => {
-        process4.exit(1);
-      }, 5e3);
+      this.serverStatus = "STOPPED";
+    }
+  }
+  /**
+   * Gets the current server state information.
+   *
+   * @method getServerState
+   * @public
+   *
+   * @returns {IServerStateInfo} Server state information object
+   *
+   * @remarks
+   * Includes:
+   * - Status, host, port
+   * - Route and dependency counts
+   * - Uptime and memory usage
+   * - HMR configuration and statistics
+   */
+  getServerState() {
+    const now = /* @__PURE__ */ new Date();
+    const uptime = this.serverStartTime ? now.getTime() - this.serverStartTime.getTime() : 0;
+    return {
+      status: this.serverStatus,
+      isRunning: this.server !== void 0 && this.serverStatus === "READY",
+      host: this.getEnvironment.appHost,
+      port: Number(this.getEnvironment.appPort),
+      language: this.localLanguage,
+      routesCount: this.currentRoutes.length,
+      dependenciesCount: this.currentDependencies.length,
+      startTime: this.serverStartTime,
+      currentTime: now,
+      uptime,
+      uptimeFormatted: this.formatUptime(uptime),
+      memoryUsage: process4.memoryUsage(),
+      pid: process4.pid,
+      platform: process4.platform,
+      nodeVersion: process4.version,
+      cwd: process4.cwd(),
+      hmrEnabled: this.getEnvironment.hmrEnabled,
+      hmrWatchingFiles: this.getEnvironment.hmrWatchPatterns?.length || 0,
+      hmrRestartCount: this.hmrRestartCount
+    };
+  }
+  /**
+   * Gets the current server status.
+   *
+   * @method getServerStatus
+   * @public
+   *
+   * @returns {TServerStatus} Current server status
+   */
+  getServerStatus() {
+    return this.serverStatus;
+  }
+  /**
+   * Gets detailed server statistics.
+   *
+   * @method getServerStats
+   * @public
+   *
+   * @returns {IServerStats} Server statistics object
+   *
+   * @remarks
+   * Includes:
+   * - Performance metrics (CPU, memory)
+   * - Uptime information
+   * - HMR statistics
+   */
+  getServerStats() {
+    const uptime = this.serverStartTime ? Date.now() - this.serverStartTime.getTime() : 0;
+    const memory = process4.memoryUsage();
+    return {
+      status: this.serverStatus,
+      uptime: this.formatUptime(uptime),
+      memory: {
+        rss: this.formatBytes(memory.rss),
+        heapTotal: this.formatBytes(memory.heapTotal),
+        heapUsed: this.formatBytes(memory.heapUsed),
+        external: this.formatBytes(memory.external)
+      },
+      performance: {
+        cpuUsage: process4.cpuUsage(),
+        resourceUsage: process4.resourceUsage?.()
+      },
+      hmrStats: {
+        enabled: this.getEnvironment.hmrEnabled,
+        restartCount: this.hmrRestartCount,
+        lastRestartTime: this.lastHmrRestartTime,
+        watchingFiles: this.getEnvironment.hmrWatchPatterns?.length || 0
+      }
+    };
+  }
+  /**
+   * Formats milliseconds into a human-readable uptime string.
+   *
+   * @method formatUptime
+   * @private
+   *
+   * @param {number} ms - Milliseconds to format
+   *
+   * @returns {string} Formatted uptime string
+   *
+   * @example
+   * formatUptime(3661000) // returns "1h 1m 1s"
+   */
+  formatUptime(ms) {
+    const seconds = Math.floor(ms / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) {
+      return `${days}d ${hours % 24}h ${minutes % 60}m`;
+    } else if (hours > 0) {
+      return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+    } else if (minutes > 0) {
+      return `${minutes}m ${seconds % 60}s`;
     } else {
-      process4.exit(0);
+      return `${seconds}s`;
+    }
+  }
+  /**
+   * Formats bytes into a human-readable size string.
+   *
+   * @method formatBytes
+   * @private
+   *
+   * @param {number} bytes - Bytes to format
+   *
+   * @returns {string} Formatted size string
+   *
+   * @example
+   * formatBytes(1048576) // returns "1.00 MB"
+   */
+  formatBytes(bytes) {
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let value = bytes;
+    let unitIndex = 0;
+    while (value >= 1024 && unitIndex < units.length - 1) {
+      value /= 1024;
+      unitIndex++;
     }
+    return `${value.toFixed(2)} ${units[unitIndex]}`;
+  }
+  /**
+   * Checks if HMR is currently active.
+   *
+   * @method isHMRActive
+   * @public
+   *
+   * @returns {boolean} True if HMR is enabled and watching files, false otherwise
+   */
+  isHMRActive() {
+    return this.getEnvironment.hmrEnabled && this.fileWatcher !== null;
+  }
+  /**
+   * Gets detailed HMR information and status.
+   *
+   * @method getHMRInfo
+   * @public
+   *
+   * @returns {any} HMR information object
+   *
+   * @remarks
+   * Includes:
+   * - Configuration settings from .env
+   * - Current restart count
+   * - Watcher status
+   */
+  getHMRInfo() {
+    return {
+      enabled: this.getEnvironment.hmrEnabled,
+      watchPatterns: this.getEnvironment.hmrWatchPatterns,
+      ignorePatterns: this.getEnvironment.hmrIgnorePatterns,
+      debounceMs: this.getEnvironment.hmrDebounceMs,
+      maxRestarts: this.getEnvironment.hmrMaxRestarts,
+      autoRestart: this.getEnvironment.hmrAutoRestarts,
+      currentRestartCount: this.hmrRestartCount,
+      lastRestartTime: this.lastHmrRestartTime,
+      isWatching: this.fileWatcher !== null,
+      isRestartPending: this.hmrRestartPending
+    };
   }
 };
 export {