@v-ibe/core 0.1.0

package/dist/router/router.js

@@ -0,0 +1,308 @@
+import { Inject } from "../DI/decorators/inject.js";
+import { Service } from "../DI/decorators/service.js";
+import { State } from "../reactivity/decorators/state.js";
+import { Effect } from "../reactivity/decorators/effect.js";
+import { Computed } from "../reactivity/decorators/computed.js";
+import { Trie } from "./trie.js";
+import { PolicyEvaluator } from "./policy-evaluator.js";
+import { reactiveContext } from "../reactivity/reactive-context.js";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _syncRouteCandidates_dec, _syncQueryParams_dec, _syncRouteParams_dec, _$routeCandidates_dec, _$queryParams_dec, _$params_dec, _policyEvaluator_dec, _routeTrie_dec, _activePatterns_dec, _currentPath_dec, _search_dec, _pathname_dec, _Router_decorators, _init;
+_Router_decorators = [Service], _pathname_dec = [State], _search_dec = [State], _currentPath_dec = [Computed], _activePatterns_dec = [Computed], _routeTrie_dec = [Inject(Trie)], _policyEvaluator_dec = [Inject(PolicyEvaluator)], _$params_dec = [State], _$queryParams_dec = [State], _$routeCandidates_dec = [State], _syncRouteParams_dec = [Effect], _syncQueryParams_dec = [Effect], _syncRouteCandidates_dec = [Effect];
+class Router {
+  constructor() {
+    __runInitializers(_init, 5, this);
+    this.pathname = __runInitializers(_init, 8, this, ""), __runInitializers(_init, 11, this);
+    this.search = __runInitializers(_init, 12, this, ""), __runInitializers(_init, 15, this);
+    this.routeTrie = __runInitializers(_init, 16, this), __runInitializers(_init, 19, this);
+    this.policyEvaluator = __runInitializers(_init, 20, this), __runInitializers(_init, 23, this);
+    this.$params = __runInitializers(_init, 24, this, {}), __runInitializers(_init, 27, this);
+    this.$queryParams = __runInitializers(_init, 28, this, {}), __runInitializers(_init, 31, this);
+    this.$routeCandidates = __runInitializers(_init, 32, this, []), __runInitializers(_init, 35, this);
+    this.hasInitialized = false;
+    this.routesLoaded = false;
+    this.$routeCandidates = [];
+  }
+  get currentPath() {
+    return this.pathname;
+  }
+  get activePatterns() {
+    return this.$routeCandidates.map(
+      (candidates) => candidates.length > 0 ? candidates[0].path : ""
+    ).filter((path) => path !== "");
+  }
+  async onBootstrap() {
+    if (this.hasInitialized) return;
+    if (!this.routesLoaded) {
+      await this.loadGeneratedRoutes();
+    }
+    this.hasInitialized = true;
+    window.addEventListener("popstate", () => {
+      this.pathname = window.location.pathname;
+      this.search = window.location.search;
+    });
+    this.pathname = window.location.pathname;
+    this.search = window.location.search;
+  }
+  syncRouteParams() {
+    const match = this.routeTrie.find(this.pathname);
+    const currentKeys = reactiveContext.untrack(() => Object.keys(this.$params));
+    if (match) {
+      const newParams = match.params;
+      for (const key of currentKeys) {
+        if (!(key in newParams)) {
+          delete this.$params[key];
+        }
+      }
+      for (const key in newParams) {
+        this.$params[key] = newParams[key];
+      }
+    } else {
+      for (const key of currentKeys) {
+        delete this.$params[key];
+      }
+    }
+  }
+  syncQueryParams() {
+    const searchParams = new URLSearchParams(this.search);
+    const currentKeys = reactiveContext.untrack(() => Object.keys(this.$queryParams));
+    for (const key of currentKeys) {
+      if (!searchParams.has(key)) {
+        delete this.$queryParams[key];
+      }
+    }
+    searchParams.forEach((value, key) => {
+      this.$queryParams[key] = value;
+    });
+  }
+  syncRouteCandidates() {
+    const match = this.routeTrie.find(this.pathname);
+    const maxDepth = this.routeTrie.maxDepth;
+    const currentLength = reactiveContext.untrack(() => this.$routeCandidates.length);
+    if (currentLength < maxDepth) {
+      for (let i = currentLength; i < maxDepth; i++) {
+        this.$routeCandidates.push([]);
+      }
+    } else if (currentLength > maxDepth) {
+      this.$routeCandidates.length = maxDepth;
+    }
+    if (match) {
+      const { candidatesByLevel } = match;
+      for (let i = 0; i < maxDepth; i++) {
+        const newCandidates = candidatesByLevel[i] || [];
+        const currentCandidates = reactiveContext.untrack(() => this.$routeCandidates[i]);
+        if (!this.candidatesAreEqual(currentCandidates, newCandidates)) {
+          this.$routeCandidates[i] = newCandidates;
+        }
+      }
+    } else {
+      for (let i = 0; i < maxDepth; i++) {
+        const currentCandidates = reactiveContext.untrack(() => this.$routeCandidates[i]);
+        if (currentCandidates.length > 0) {
+          this.$routeCandidates[i] = [];
+        }
+      }
+    }
+  }
+  /**
+   * Compara dos arrays de candidatos para determinar si son iguales
+   * Usa comparación por id para determinar identidad
+   */
+  candidatesAreEqual(a, b) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (a[i].id !== b[i].id) return false;
+    }
+    return true;
+  }
+  /**
+   * Fuerza la re-evaluación de todos los route candidates
+   * recalculando los candidatos desde el Trie.
+   *
+   * Esto hace que todos los RouteView detecten el cambio y re-ejecuten
+   * sus Resources, incluyendo la evaluación de policies.
+   *
+   * Útil después de cambios de estado que afectan autorización (ej: OAuth login)
+   */
+  revalidateRouteCandidates() {
+    console.log("[Router] Revalidating all route candidates");
+    const match = this.routeTrie.find(this.pathname);
+    const maxDepth = this.routeTrie.maxDepth;
+    if (match) {
+      const { candidatesByLevel } = match;
+      for (let i = 0; i < maxDepth; i++) {
+        const newCandidates = candidatesByLevel[i] || [];
+        this.$routeCandidates[i] = [...newCandidates];
+      }
+    } else {
+      for (let i = 0; i < maxDepth; i++) {
+        this.$routeCandidates[i] = [];
+      }
+    }
+  }
+  navigate(to, options) {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(to) || to.startsWith("//")) {
+      if (options?.external === "native" || options?.external === void 0) {
+        window.location.href = to;
+        return;
+      }
+      if (options?.external === "block") {
+        console.warn(`[Router] External navigation blocked: ${to}`);
+        return;
+      }
+    }
+    const currentUrl = window.location.href;
+    const url = new URL(to, currentUrl);
+    const newPathname = url.pathname;
+    const newSearch = url.search;
+    const newHash = url.hash;
+    const pathnameChanged = this.pathname !== newPathname;
+    const searchChanged = this.search !== newSearch;
+    if (!pathnameChanged && !searchChanged && !options?.revalidate) {
+      return;
+    }
+    const fullPath = newPathname + newSearch + newHash;
+    const historyMethod = options?.replace ? "replaceState" : "pushState";
+    window.history[historyMethod](null, "", fullPath);
+    if (pathnameChanged) {
+      this.pathname = newPathname;
+    }
+    if (searchChanged) {
+      this.search = newSearch;
+    }
+    if (options?.revalidate) {
+      this.revalidateRouteCandidates();
+    }
+  }
+  /**
+   * Carga las rutas generadas por el plugin de Vite
+   * Intenta múltiples rutas posibles donde el archivo puede estar generado
+   */
+  async loadGeneratedRoutes() {
+    const possiblePaths = [
+      "/app/router/generated-routes",
+      // Ruta más común según el plugin
+      "@/router/generated-routes",
+      // Usando alias @ si está configurado
+      "/src/router/generated-routes",
+      // Alternativa común
+      "/router/generated-routes",
+      // Si está en la raíz
+      "./app/router/generated-routes",
+      // Relativa (fallback)
+      "./src/router/generated-routes"
+      // Relativa (fallback)
+    ];
+    let routes = null;
+    let lastError = null;
+    for (const routePath of possiblePaths) {
+      try {
+        const module = await import(
+          /* @vite-ignore */
+          routePath
+        );
+        routes = module.default || module.routes || null;
+        if (routes && Array.isArray(routes)) {
+          break;
+        } else {
+          console.log(`[Router.loadGeneratedRoutes] ⚠️  ${routePath} existe pero no exporta rutas válidas`);
+        }
+      } catch (error) {
+        lastError = error;
+        console.log(`[Router.loadGeneratedRoutes] ❌ Error en ${routePath}:`, error.message);
+        continue;
+      }
+    }
+    if (!routes || !Array.isArray(routes)) {
+      console.warn("⚠️  Could not load generated routes. Make sure the route generator plugin is configured correctly.");
+      console.warn("   Tried paths:", possiblePaths);
+      if (lastError) {
+        console.warn("   Last error:", lastError.message);
+      }
+      console.warn("   Tip: Make sure generated-routes.ts exists and exports default an array of routes.");
+      return;
+    }
+    this.registerGeneratedRoutes(routes);
+    this.routesLoaded = true;
+  }
+  /**
+   * Registra un array de rutas generadas en el Trie
+   * @param routes Array de rutas generadas por el plugin
+   */
+  registerGeneratedRoutes(routes) {
+    for (const route of routes) {
+      this.routeTrie.insert(
+        route.id,
+        route.path,
+        route.loader,
+        route.metadata,
+        route.policies,
+        route.slot
+      );
+    }
+  }
+}
+_init = __decoratorStart();
+__decorateElement(_init, 2, "currentPath", _currentPath_dec, Router);
+__decorateElement(_init, 2, "activePatterns", _activePatterns_dec, Router);
+__decorateElement(_init, 1, "syncRouteParams", _syncRouteParams_dec, Router);
+__decorateElement(_init, 1, "syncQueryParams", _syncQueryParams_dec, Router);
+__decorateElement(_init, 1, "syncRouteCandidates", _syncRouteCandidates_dec, Router);
+__decorateElement(_init, 5, "pathname", _pathname_dec, Router);
+__decorateElement(_init, 5, "search", _search_dec, Router);
+__decorateElement(_init, 5, "routeTrie", _routeTrie_dec, Router);
+__decorateElement(_init, 5, "policyEvaluator", _policyEvaluator_dec, Router);
+__decorateElement(_init, 5, "$params", _$params_dec, Router);
+__decorateElement(_init, 5, "$queryParams", _$queryParams_dec, Router);
+__decorateElement(_init, 5, "$routeCandidates", _$routeCandidates_dec, Router);
+Router = __decorateElement(_init, 0, "Router", _Router_decorators, Router);
+__runInitializers(_init, 1, Router);
+export {
+  Router
+};

package/dist/router/static-analysis/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Static Analysis Module for Route Decorators
+ *
+ * Este módulo proporciona herramientas para analizar estáticamente
+ * decoradores @Route en archivos TypeScript y extraer información
+ * sobre las rutas de la aplicación.
+ *
+ * @module static-analysis
+ * @packageDocumentation
+ */
+export { parseRouteDecorators, type ParsedRoute } from './parser';
+export { scanDirectory, printScanSummary, type ScanResult, type ScanOptions } from './scanner';
+/**
+ * @example Parser básico
+ * ```typescript
+ * import { parseRouteDecorators } from '@framework/router/static-analysis';
+ *
+ * const routes = parseRouteDecorators('./src/pages/products.ts');
+ * console.log(routes);
+ * // [
+ * //   {
+ * //     path: '/products',
+ * //     className: 'ProductsPage',
+ * //     filePath: './src/pages/products.ts',
+ * //     raw: '@Route("/products")'
+ * //   }
+ * // ]
+ * ```
+ *
+ * @example Scanner de directorios
+ * ```typescript
+ * import { scanDirectory } from '@framework/router/static-analysis';
+ *
+ * const result = await scanDirectory('./src/pages');
+ * console.log(`Found ${result.totalRoutes} routes in ${result.filesWithRoutes} files`);
+ * ```
+ */ 

package/dist/router/static-analysis/parser.d.ts

@@ -0,0 +1,14 @@
+export interface ParsedRoute {
+    path: string;
+    className: string;
+    filePath: string;
+    metadata?: Record<string, any>;
+    policies?: string[];
+    slot?: string;
+    raw: string;
+}
+/**
+ * Parser básico de decoradores @Route
+ * Lee un archivo TypeScript y detecta decoradores @Route
+ */
+export declare function parseRouteDecorators(filePath: string): ParsedRoute[];

package/dist/router/static-analysis/parser.js

@@ -0,0 +1,147 @@
+import * as ts from "typescript";
+function parseRouteDecorators(filePath) {
+  const program = ts.createProgram([filePath], {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext
+  });
+  const sourceFile = program.getSourceFile(filePath);
+  if (!sourceFile) {
+    throw new Error(`Could not load source file: ${filePath}`);
+  }
+  const routes = [];
+  const sourceFileNonNull = sourceFile;
+  function visit(node) {
+    if (ts.isClassDeclaration(node)) {
+      const className = node.name?.getText(sourceFileNonNull) || "AnonymousClass";
+      let decorators;
+      if (ts.canHaveDecorators(node)) {
+        decorators = ts.getDecorators(node);
+      }
+      if (!decorators && node.decorators) {
+        decorators = node.decorators;
+      }
+      if (decorators && decorators.length > 0) {
+        decorators.forEach((decorator) => {
+          const text = decorator.getText(sourceFileNonNull);
+          if (text.includes("@Route") || text.includes("Route(")) {
+            const parsedRoute = parseRouteDecoratorExpression(decorator, sourceFileNonNull, className, filePath);
+            if (parsedRoute) {
+              routes.push(parsedRoute);
+            } else {
+              routes.push({
+                raw: text,
+                className,
+                filePath,
+                path: ""
+                // No pudimos extraer el path
+              });
+            }
+          }
+        });
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFileNonNull);
+  return routes;
+}
+function parseRouteDecoratorExpression(decorator, sourceFile, className, filePath) {
+  const expression = decorator.expression;
+  if (ts.isCallExpression(expression)) {
+    const args = expression.arguments;
+    if (args.length > 0) {
+      const pathArg = args[0];
+      if (ts.isStringLiteral(pathArg)) {
+        const path = pathArg.text;
+        const raw = decorator.getText(sourceFile);
+        const result = {
+          path,
+          className,
+          filePath,
+          raw
+        };
+        if (args.length > 1) {
+          const configArg = args[1];
+          if (ts.isObjectLiteralExpression(configArg)) {
+            const config = parseConfigObject(configArg, sourceFile);
+            if (config.metadata) {
+              result.metadata = config.metadata;
+            }
+            if (config.policies) {
+              result.policies = config.policies;
+            }
+            if (config.slot) {
+              result.slot = config.slot;
+            }
+          }
+        }
+        return result;
+      }
+    }
+  }
+  return null;
+}
+function parseConfigObject(objectLiteral, sourceFile) {
+  const config = {};
+  objectLiteral.properties.forEach((prop) => {
+    if (ts.isPropertyAssignment(prop)) {
+      const name = prop.name.getText(sourceFile);
+      if (name === "policies" && ts.isArrayLiteralExpression(prop.initializer)) {
+        config.policies = prop.initializer.elements.map((el) => el.getText(sourceFile)).filter(Boolean);
+      } else if (name === "metadata" && ts.isObjectLiteralExpression(prop.initializer)) {
+        config.metadata = parseMetadataObject(prop.initializer, sourceFile);
+      } else if (name === "slot" && ts.isStringLiteral(prop.initializer)) {
+        config.slot = prop.initializer.text;
+      }
+    }
+  });
+  return config;
+}
+function parseMetadataObject(objectLiteral, sourceFile) {
+  const metadata = {};
+  objectLiteral.properties.forEach((prop) => {
+    if (ts.isPropertyAssignment(prop)) {
+      const key = prop.name.getText(sourceFile);
+      const value = parseValue(prop.initializer, sourceFile);
+      metadata[key] = value;
+    } else if (ts.isShorthandPropertyAssignment(prop)) {
+      const key = prop.name.getText(sourceFile);
+      metadata[key] = key;
+    }
+  });
+  return metadata;
+}
+function parseValue(node, sourceFile) {
+  if (node.kind === ts.SyntaxKind.TrueKeyword) {
+    return true;
+  }
+  if (node.kind === ts.SyntaxKind.FalseKeyword) {
+    return false;
+  }
+  if (ts.isStringLiteral(node)) {
+    return node.text;
+  }
+  if (ts.isNumericLiteral(node)) {
+    const num = parseFloat(node.text);
+    return isNaN(num) ? node.text : num;
+  }
+  if (node.kind === ts.SyntaxKind.NullKeyword) {
+    return null;
+  }
+  if (node.kind === ts.SyntaxKind.UndefinedKeyword) {
+    return void 0;
+  }
+  if (ts.isObjectLiteralExpression(node)) {
+    return parseMetadataObject(node, sourceFile);
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    return node.elements.map((el) => parseValue(el, sourceFile));
+  }
+  if (ts.isTemplateExpression(node)) {
+    return node.getText(sourceFile);
+  }
+  return node.getText(sourceFile);
+}
+export {
+  parseRouteDecorators
+};

package/dist/router/static-analysis/scanner.d.ts

@@ -0,0 +1,27 @@
+import { ParsedRoute } from './parser';
+export type { ParsedRoute };
+/**
+ * Resultado del escaneo de directorios
+ */
+export interface ScanResult {
+    routes: ParsedRoute[];
+    filesScanned: number;
+    filesWithRoutes: number;
+    totalRoutes: number;
+}
+/**
+ * Opciones para el scanner
+ */
+export interface ScanOptions {
+    extensions?: string[];
+    exclude?: string[];
+    verbose?: boolean;
+}
+/**
+ * Escanea recursivamente un directorio buscando archivos con decoradores @Route
+ */
+export declare function scanDirectory(dirPath: string, options?: ScanOptions): Promise<ScanResult>;
+/**
+ * Imprime un resumen bonito del escaneo
+ */
+export declare function printScanSummary(result: ScanResult): void;

package/dist/router/static-analysis/scanner.js

@@ -0,0 +1,91 @@
+import fs from "fs/promises";
+import path from "path";
+import { parseRouteDecorators } from "./parser.js";
+const DEFAULT_OPTIONS = {
+  extensions: [".ts", ".tsx"],
+  exclude: ["node_modules", "dist", "build", ".git"],
+  verbose: false
+};
+async function scanDirectory(dirPath, options = {}) {
+  const config = { ...DEFAULT_OPTIONS, ...options };
+  log(config, `
+🔍 Scanning directory: ${dirPath}`);
+  const files = await getAllTypeScriptFiles(dirPath, config);
+  log(config, `📂 Found ${files.length} TypeScript files`);
+  const routes = await extractRoutesFromFiles(files, config);
+  const filesWithRoutes = new Set(routes.map((r) => r.filePath)).size;
+  return {
+    routes,
+    filesScanned: files.length,
+    filesWithRoutes,
+    totalRoutes: routes.length
+  };
+}
+async function getAllTypeScriptFiles(dirPath, config) {
+  const files = [];
+  await traverseDirectory(dirPath, async (filePath) => {
+    if (isTypeScriptFile(filePath, config)) {
+      files.push(filePath);
+    }
+  }, config);
+  return files;
+}
+async function traverseDirectory(dirPath, onFile, config) {
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        if (shouldExcludeDirectory(entry.name, config)) {
+          continue;
+        }
+        await traverseDirectory(fullPath, onFile, config);
+      } else if (entry.isFile()) {
+        await onFile(fullPath);
+      }
+    }
+  } catch (error) {
+    log(config, `⚠️  Cannot read directory: ${dirPath}`);
+  }
+}
+function isTypeScriptFile(filePath, config) {
+  return config.extensions.some((ext) => filePath.endsWith(ext));
+}
+function shouldExcludeDirectory(dirName, config) {
+  return config.exclude.includes(dirName);
+}
+async function extractRoutesFromFiles(files, config) {
+  const allRoutes = [];
+  for (const filePath of files) {
+    const hasRoutes = await quickCheckForRouteDecorator(filePath);
+    if (!hasRoutes) {
+      continue;
+    }
+    try {
+      const routes = parseRouteDecorators(filePath);
+      if (routes.length > 0) {
+        log(config, `  ✓ ${path.basename(filePath)}: ${routes.length} route(s)`);
+        allRoutes.push(...routes);
+      }
+    } catch (error) {
+      log(config, `  ✗ Error parsing ${filePath}: ${error}`);
+    }
+  }
+  return allRoutes;
+}
+async function quickCheckForRouteDecorator(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return content.includes("@Route");
+  } catch {
+    return false;
+  }
+}
+function log(config, message) {
+  if (config.verbose) {
+    console.log(message);
+  }
+}
+export {
+  scanDirectory
+};

package/dist/router/trie.d.ts

@@ -0,0 +1,14 @@
+import { FindResult } from './trie.types';
+import { Constructor } from '../DI/types';
+export declare class Trie {
+    private readonly root;
+    private _maxDepth;
+    insert(id: string, path: string, loader: () => Promise<any>, metadata?: Record<string, any>, policies?: Constructor<any>[], slot?: string): void;
+    find(path: string): FindResult | null;
+    /**
+     * Retorna la profundidad máxima de rutas registradas en el Trie
+     * @returns Número de niveles (0 = solo root, 1 = un segmento, etc.)
+     */
+    get maxDepth(): number;
+    private createNode;
+}