@v-ibe/core 0.1.0

package/dist/vite-plugins/jsx-signals.js

@@ -0,0 +1,124 @@
+import ts__default from "typescript";
+function jsxSignalsPlugin() {
+  return {
+    name: "jsx-signals",
+    enforce: "pre",
+    transform(code, id) {
+      if (!id.endsWith(".tsx") && !id.endsWith(".jsx")) {
+        return null;
+      }
+      const sourceFile = ts__default.createSourceFile(
+        id,
+        code,
+        ts__default.ScriptTarget.Latest,
+        true,
+        ts__default.ScriptKind.TSX
+      );
+      const transformer = (context) => {
+        return (sourceFile2) => {
+          const visit = (node) => {
+            if (ts__default.isCallExpression(node) && ts__default.isPropertyAccessExpression(node.expression) && node.expression.name.text === "map") ;
+            if (ts__default.isJsxAttribute(node) && node.initializer && ts__default.isJsxExpression(node.initializer)) {
+              const attributeName = node.name.getText(sourceFile2);
+              const jsxExpression = node.initializer;
+              if (isEventHandler(attributeName)) {
+                return ts__default.visitEachChild(node, visit, context);
+              }
+              if (jsxExpression.expression && containsThis(jsxExpression.expression)) {
+                if (ts__default.isArrowFunction(jsxExpression.expression) || ts__default.isFunctionExpression(jsxExpression.expression)) {
+                  return ts__default.visitEachChild(node, visit, context);
+                }
+                const arrowFunction = ts__default.factory.createArrowFunction(
+                  void 0,
+                  void 0,
+                  [],
+                  void 0,
+                  ts__default.factory.createToken(ts__default.SyntaxKind.EqualsGreaterThanToken),
+                  jsxExpression.expression
+                );
+                const newJsxExpression = ts__default.factory.updateJsxExpression(
+                  jsxExpression,
+                  arrowFunction
+                );
+                return ts__default.factory.updateJsxAttribute(
+                  node,
+                  node.name,
+                  newJsxExpression
+                );
+              }
+            }
+            if (ts__default.isJsxExpression(node) && node.expression && !ts__default.isJsxAttribute(node.parent)) {
+              const expr = node.expression;
+              if (ts__default.isArrowFunction(expr) || ts__default.isFunctionExpression(expr)) {
+                return ts__default.visitEachChild(node, visit, context);
+              }
+              if (ts__default.isCallExpression(expr)) {
+                const visitedNode = ts__default.visitEachChild(node, visit, context);
+                const visitedExpr = visitedNode.expression;
+                if (containsThis(visitedExpr)) {
+                  const arrowFunction = ts__default.factory.createArrowFunction(
+                    void 0,
+                    void 0,
+                    [],
+                    void 0,
+                    ts__default.factory.createToken(ts__default.SyntaxKind.EqualsGreaterThanToken),
+                    visitedExpr
+                  );
+                  return ts__default.factory.updateJsxExpression(visitedNode, arrowFunction);
+                }
+                return visitedNode;
+              }
+              if (containsThis(expr)) {
+                const visitedNode = ts__default.visitEachChild(node, visit, context);
+                const visitedExpr = visitedNode.expression;
+                const arrowFunction = ts__default.factory.createArrowFunction(
+                  void 0,
+                  void 0,
+                  [],
+                  void 0,
+                  ts__default.factory.createToken(ts__default.SyntaxKind.EqualsGreaterThanToken),
+                  visitedExpr
+                );
+                return ts__default.factory.updateJsxExpression(visitedNode, arrowFunction);
+              }
+            }
+            return ts__default.visitEachChild(node, visit, context);
+          };
+          return ts__default.visitEachChild(sourceFile2, visit, context);
+        };
+      };
+      function isEventHandler(attributeName) {
+        return attributeName.startsWith("on") && attributeName.length > 2;
+      }
+      function containsThis(expr) {
+        let hasThis = false;
+        const visitor = (node) => {
+          if (hasThis) return;
+          if (ts__default.isPropertyAccessExpression(node) && node.expression.kind === ts__default.SyntaxKind.ThisKeyword || ts__default.isElementAccessExpression(node) && node.expression.kind === ts__default.SyntaxKind.ThisKeyword || ts__default.isCallExpression(node) && ts__default.isPropertyAccessExpression(node.expression) && node.expression.expression.kind === ts__default.SyntaxKind.ThisKeyword || node.kind === ts__default.SyntaxKind.ThisKeyword) {
+            hasThis = true;
+            return;
+          }
+          ts__default.forEachChild(node, visitor);
+        };
+        visitor(expr);
+        return hasThis;
+      }
+      const result = ts__default.transform(sourceFile, [transformer]);
+      const transformedFile = result.transformed[0];
+      const printer = ts__default.createPrinter({
+        newLine: ts__default.NewLineKind.LineFeed,
+        removeComments: false,
+        omitTrailingSemicolon: false
+      });
+      const newCode = printer.printFile(transformedFile);
+      result.dispose();
+      return {
+        code: newCode,
+        map: null
+      };
+    }
+  };
+}
+export {
+  jsxSignalsPlugin
+};

package/dist/vite-plugins/router/route-generator-plugin.d.ts

@@ -0,0 +1,63 @@
+import { Plugin } from 'vite';
+/**
+ * Opciones de configuración para el plugin de generación de rutas
+ *
+ * IMPORTANTE: Todas las rutas son relativas al directorio raíz del proyecto del usuario,
+ * no al directorio del framework. El plugin se ejecuta en el contexto del proyecto
+ * donde está instalado el framework como dependencia.
+ */
+export interface RouteGeneratorPluginOptions {
+    /**
+     * Directorio raíz donde buscar archivos con decoradores @Route
+     * Relativo al root del proyecto del usuario
+     * @default 'app'
+     */
+    srcDir?: string;
+    /**
+     * Ruta donde se generará el archivo de rutas
+     * Relativo al root del proyecto del usuario
+     * @default 'app/router/generated-routes.ts'
+     */
+    outputPath?: string;
+    /**
+     * Extensiones de archivo a escanear
+     * @default ['.ts', '.tsx']
+     */
+    extensions?: string[];
+    /**
+     * Directorios a excluir del escaneo
+     * @default ['node_modules', 'dist', 'build', '.git']
+     */
+    exclude?: string[];
+    /**
+     * Activar logs detallados
+     * @default false
+     */
+    verbose?: boolean;
+}
+/**
+ * Plugin de Vite para generación automática de rutas
+ *
+ * Escanea el proyecto del usuario buscando decoradores @Route y genera un archivo
+ * TypeScript con todas las rutas encontradas para registro automático en el Trie.
+ *
+ * El plugin trabaja en el contexto del proyecto donde el framework está instalado,
+ * por lo que todas las rutas son relativas al proyecto del usuario, no al framework.
+ *
+ * @example
+ * ```typescript
+ * // vite.config.ts (en el proyecto del usuario)
+ * import { routeGeneratorPlugin } from '@v-ibe/core/vite-plugins';
+ *
+ * export default defineConfig({
+ *   plugins: [
+ *     routeGeneratorPlugin({
+ *       srcDir: 'app',                              // carpeta del usuario
+ *       outputPath: 'app/router/generated-routes.ts', // genera aquí
+ *       verbose: true
+ *     })
+ *   ]
+ * });
+ * ```
+ */
+export declare function routeGeneratorPlugin(options?: RouteGeneratorPluginOptions): Plugin;

package/dist/vite-plugins/router/route-generator-plugin.js

@@ -0,0 +1,310 @@
+import path from "path";
+import fs from "fs/promises";
+import { existsSync } from "fs";
+import { randomUUID } from "node:crypto";
+import { scanDirectory } from "../../router/static-analysis/scanner.js";
+const DEFAULT_OPTIONS = {
+  srcDir: "app",
+  outputPath: "app/router/generated-routes.ts",
+  extensions: [".ts", ".tsx"],
+  exclude: ["node_modules", "dist", "build", ".git", "framework"],
+  verbose: false
+};
+function routeGeneratorPlugin(options = {}) {
+  const config = { ...DEFAULT_OPTIONS, ...options };
+  let server;
+  let projectRoot;
+  return {
+    name: "vite-plugin-route-generator",
+    configResolved(resolvedConfig) {
+      projectRoot = resolvedConfig.root;
+      log(config, `
+🚀 Route Generator Plugin initialized`);
+      log(config, `   Project root: ${projectRoot}`);
+      log(config, `   Scanning: ${config.srcDir}`);
+      log(config, `   Output: ${config.outputPath}
+`);
+    },
+    async buildStart() {
+      log(config, "\n🔍 Scanning for routes...\n");
+      await generateRoutesFile(projectRoot, config);
+    },
+    configureServer(devServer) {
+      server = devServer;
+      devServer.watcher.on("change", async (filePath) => {
+        if (shouldProcessFile(filePath, config)) {
+          log(config, `
+📝 File changed: ${path.basename(filePath)}`);
+          await regenerateRoutes(projectRoot, config, server);
+        }
+      });
+      devServer.watcher.on("add", async (filePath) => {
+        if (shouldProcessFile(filePath, config)) {
+          log(config, `
+➕ File added: ${path.basename(filePath)}`);
+          await regenerateRoutes(projectRoot, config, server);
+        }
+      });
+      devServer.watcher.on("unlink", async (filePath) => {
+        if (shouldProcessFile(filePath, config)) {
+          log(config, `
+➖ File removed: ${path.basename(filePath)}`);
+          await regenerateRoutes(projectRoot, config, server);
+        }
+      });
+    }
+  };
+}
+async function generateRoutesFile(projectRoot, config) {
+  const srcPath = path.resolve(projectRoot, config.srcDir);
+  try {
+    const result = await scanDirectory(srcPath, {
+      extensions: config.extensions,
+      exclude: config.exclude,
+      verbose: false
+      // Silencioso para no contaminar logs
+    });
+    if (result.totalRoutes === 0) {
+      log(config, `⚠️  No routes found in ${config.srcDir}`);
+      log(config, `   Make sure you have classes decorated with @Route`);
+      return;
+    }
+    log(config, `✅ Found ${result.totalRoutes} routes in ${result.filesWithRoutes} files`);
+    const generatedCode = generateTypeScriptCode(result.routes, projectRoot, config);
+    const outputPath = path.resolve(projectRoot, config.outputPath);
+    await ensureDirectoryExists(path.dirname(outputPath));
+    await fs.writeFile(outputPath, generatedCode, "utf-8");
+    log(config, `✅ Routes file generated: ${config.outputPath}
+`);
+  } catch (error) {
+    console.error("❌ Error generating routes:", error);
+    console.error("   Check that the srcDir exists and contains valid TypeScript files");
+    throw error;
+  }
+}
+async function regenerateRoutes(projectRoot, config, server) {
+  await generateRoutesFile(projectRoot, config);
+  if (server) {
+    const outputPath = path.resolve(projectRoot, config.outputPath);
+    const module = server.moduleGraph.getModuleById(outputPath);
+    if (module) {
+      server.moduleGraph.invalidateModule(module);
+      server.ws.send({
+        type: "full-reload",
+        path: "*"
+      });
+      log(config, "🔄 Hot reload triggered\n");
+    }
+  }
+}
+function generateTypeScriptCode(routes, projectRoot, config) {
+  const imports = generateImports(routes, projectRoot, config);
+  const routesArray = generateRoutesArray(routes, projectRoot, config);
+  const typeDefinitions = generateTypeDefinitions();
+  const routeTypes = generateRouteTypes(routes);
+  return `/**
+ * 🚀 Auto-generated routes file
+ * 
+ * This file is automatically generated by vite-plugin-route-generator.
+ * Do not edit manually - your changes will be overwritten!
+ * 
+ * Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+ * Total routes: ${routes.length}
+ */
+
+${imports}
+
+${typeDefinitions}
+
+${routeTypes}
+
+/**
+ * Array de todas las rutas encontradas en el proyecto
+ * 
+ * Este array es importado automáticamente por el Router durante el bootstrap.
+ * No necesitas importarlo manualmente.
+ */
+const generatedRoutes: GeneratedRoute[] = ${routesArray};
+
+export default generatedRoutes;
+`;
+}
+function generateImports(routes, projectRoot, config) {
+  const policyImports = generatePolicyImports(routes, projectRoot, config);
+  if (policyImports.length === 0) {
+    return "// All components are lazy loaded with dynamic imports";
+  }
+  return `// Policy imports
+${policyImports}
+
+// All components are lazy loaded with dynamic imports`;
+}
+function generatePolicyImports(routes, projectRoot, config) {
+  const policySet = /* @__PURE__ */ new Map();
+  routes.forEach((route) => {
+    if (route.policies && route.policies.length > 0) {
+      route.policies.forEach((policyName) => {
+        if (!policySet.has(policyName)) {
+          const policyPath = findPolicyFile(policyName, projectRoot, config);
+          if (policyPath) {
+            policySet.set(policyName, policyPath);
+          }
+        }
+      });
+    }
+  });
+  const imports = [];
+  policySet.forEach((filePath, policyName) => {
+    const relativePath = getRelativeImportPath(filePath, projectRoot, config);
+    imports.push(`import { ${policyName} } from '${relativePath}';`);
+  });
+  return imports.join("\n");
+}
+function findPolicyFile(policyName, projectRoot, config) {
+  const srcDir = path.resolve(projectRoot, config.srcDir);
+  const possiblePaths = [
+    path.join(srcDir, "policies", `${kebabCase(policyName)}.ts`),
+    path.join(srcDir, "policies", `${kebabCase(policyName)}.tsx`),
+    path.join(srcDir, "policy", `${kebabCase(policyName)}.ts`),
+    path.join(srcDir, "policy", `${kebabCase(policyName)}.tsx`),
+    path.join(srcDir, "policies", `${camelToKebab(policyName)}.policy.ts`),
+    path.join(srcDir, "policies", `${camelToKebab(policyName)}.policy.tsx`)
+  ];
+  for (const possiblePath of possiblePaths) {
+    try {
+      if (existsSync(possiblePath)) {
+        return possiblePath;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return path.join(srcDir, "policies", `${camelToKebab(policyName)}.policy.ts`);
+}
+function camelToKebab(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase().replace(/-?policy$/, "");
+}
+function kebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function generateRoutesArray(routes, projectRoot, config) {
+  const routeObjects = routes.map((route) => {
+    const relativePath = getRelativeImportPath(route.filePath, projectRoot, config);
+    const metadata = route.metadata ? JSON.stringify(route.metadata) : "undefined";
+    const policies = route.policies ? `[${route.policies.join(", ")}]` : "undefined";
+    const slot = route.slot ? `'${route.slot}'` : "undefined";
+    const routeId = randomUUID();
+    return `  {
+    id: '${routeId}',
+    path: '${route.path}',
+    className: '${route.className}',
+    loader: async (signal?: AbortSignal) => {
+      const module = await import('${relativePath}');
+      return { default: module.${route.className} };
+    },
+    metadata: ${metadata},
+    policies: ${policies},
+    slot: ${slot},
+  }`;
+  });
+  return `[
+${routeObjects.join(",\n")}
+]`;
+}
+function generateTypeDefinitions(routes) {
+  return `// Types will be defined after Routes type is generated
+`;
+}
+function extractRouteParams(path2) {
+  const matches = path2.match(/:([a-zA-Z0-9_]+)/g);
+  if (!matches) return [];
+  return matches.map((match) => match.slice(1));
+}
+function generateRouteTypes(routes) {
+  const pathParamsMap = /* @__PURE__ */ new Map();
+  routes.forEach((route) => {
+    if (!pathParamsMap.has(route.path)) {
+      pathParamsMap.set(route.path, extractRouteParams(route.path));
+    }
+  });
+  const paramTypes = Array.from(pathParamsMap.entries()).map(([path2, params]) => {
+    if (params.length === 0) {
+      return `  '${path2}': Record<string, never>;`;
+    }
+    const paramObject = params.map((p) => `${p}: string`).join("; ");
+    return `  '${path2}': { ${paramObject} };`;
+  }).join("\n");
+  return `/**
+ * 🎯 Tipos de rutas generados automáticamente
+ * 
+ * Estos tipos proporcionan autocompletado y validación de tipos para router.navigate()
+ */
+
+/**
+ * Mapeo de todas las rutas a sus parámetros requeridos
+ * 
+ * @example
+ * // Ruta sin parámetros
+ * Routes['/'] -> Record<string, never>
+ * 
+ * @example
+ * // Ruta con parámetros
+ * Routes['/store/:storeId'] -> { storeId: string }
+ * 
+ * @example
+ * // Obtener todas las rutas disponibles
+ * type AllPaths = keyof Routes; // '/' | '/callback' | '/store/:storeId' | ...
+ */
+export type Routes = {
+${paramTypes}
+};
+
+/**
+ * Tipo para una ruta generada
+ * El path está tipado con las rutas disponibles (keyof Routes)
+ */
+export interface GeneratedRoute {
+  id: string;
+  path: keyof Routes;
+  className: string;
+  loader: (signal?: AbortSignal) => Promise<{ default: any }>;
+  metadata?: Record<string, any>;
+  policies?: (new (...args: any[]) => any)[];
+  slot?: string;
+}
+`;
+}
+function getRelativeImportPath(absolutePath, projectRoot, config) {
+  const outputDir = path.dirname(path.join(projectRoot, config.outputPath));
+  const relativePath = path.relative(outputDir, absolutePath);
+  const withoutExt = relativePath.replace(/\.(ts|tsx)$/, "");
+  const normalized = withoutExt.startsWith(".") ? withoutExt : `./${withoutExt}`;
+  return normalized.replace(/\\/g, "/");
+}
+function shouldProcessFile(filePath, config) {
+  if (!config.extensions.some((ext) => filePath.endsWith(ext))) {
+    return false;
+  }
+  if (config.exclude.some((excluded) => filePath.includes(excluded))) {
+    return false;
+  }
+  if (filePath.includes("generated-routes")) {
+    return false;
+  }
+  return true;
+}
+async function ensureDirectoryExists(dirPath) {
+  try {
+    await fs.access(dirPath);
+  } catch {
+    await fs.mkdir(dirPath, { recursive: true });
+  }
+}
+function log(config, message) {
+  if (config.verbose) {
+    console.log(message);
+  }
+}
+export {
+  routeGeneratorPlugin
+};

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@v-ibe/core",
+  "version": "0.1.0",
+  "description": "A reactive framework for SPAs using signals, class-based web components, and JSX with direct DOM updates",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./jsx-runtime": {
+      "types": "./dist/jsx-runtime.d.ts",
+      "import": "./dist/jsx-runtime.js",
+      "default": "./dist/jsx-runtime.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./dist/jsx-dev-runtime.d.ts",
+      "import": "./dist/jsx-dev-runtime.js",
+      "default": "./dist/jsx-dev-runtime.js"
+    },
+    "./vite-plugins": {
+      "types": "./dist/vite-plugins/index.d.ts",
+      "import": "./dist/vite-plugins/index.js",
+      "default": "./dist/vite-plugins/index.js"
+    },
+    "./app-entry": {
+      "types": "./dist/app-entry.d.ts",
+      "import": "./dist/app-entry.js",
+      "default": "./dist/app-entry.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite --config vite.config.dev.ts",
+    "prepublishOnly": "npm run build",
+    "clean": "rm -rf dist",
+    "test:parser": "tsx src/router/static-analysis/test.ts",
+    "test:scanner": "tsx src/router/static-analysis/test-scanner.ts",
+    "test:class-decorator": "tsx src/router/static-analysis/test-class-decorator.ts",
+    "test:vite-plugin": "tsx src/vite-plugins/router/test-plugin.ts",
+    "test": "vitest",
+    "test:ui": "vitest --ui",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  },
+  "keywords": [
+    "framework",
+    "signals",
+    "reactive",
+    "web-components",
+    "jsx",
+    "typescript"
+  ],
+  "author": "Julian Vargas <arboledavargas@outlook.com> (https://github.com/arboledavargas)",
+  "homepage": "https://v-ibe.com",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/arboledavargas/v-ibe.git"
+  },
+  "peerDependencies": {
+    "typescript": ">=5.0.0",
+    "vite": "^7.1.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "@vitest/ui": "^4.0.17",
+    "happy-dom": "^20.3.1",
+    "jsdom": "^27.4.0",
+    "postcss": "^8.5.6",
+    "tsx": "^4.19.2",
+    "typescript": "^5.9.2",
+    "vite": "^7.1.3",
+    "vite-plugin-dts": "^4.3.0",
+    "vitest": "^4.0.17"
+  }
+}