@kimesh/router-generator 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# @kimesh/router-generator
+
+Part of the [Kimesh](https://github.com/kimesh/kimesh) framework.

package/dist/index.d.mts

@@ -0,0 +1,505 @@
+import { Plugin } from "vite";
+
+//#region src/types.d.ts
+/**
+ * Router generator configuration
+ */
+interface KimeshRouterConfig {
+  /** Source directory (default: 'src') */
+  srcDir: string;
+  /** Routes directory relative to srcDir (default: 'routes') */
+  routesDir: string;
+  /** Generated files directory relative to srcDir (default: '.kimesh') */
+  generatedDir: string;
+  /** File extensions to scan (default: ['.vue']) */
+  extensions: string[];
+  /** Import mode for route components */
+  importMode: 'async' | 'sync' | ((filepath: string) => 'async' | 'sync');
+}
+/**
+ * Resolved router config with all defaults applied
+ */
+interface ResolvedRouterConfig extends KimeshRouterConfig {
+  /** Absolute path to routes directory */
+  routesDirPath: string;
+  /** Absolute path to generated directory */
+  generatedDirPath: string;
+  /** Project root */
+  root: string;
+}
+/**
+ * Route node type
+ */
+type RouteNodeType = 'page' | 'layout' | 'index' | 'catch-all' | 'dynamic';
+/**
+ * Scanned route node
+ */
+interface RouteNode {
+  /** File path relative to routes dir */
+  filePath: string;
+  /** Absolute file path */
+  fullPath: string;
+  /** Generated route path (e.g., '/posts/:postId') */
+  routePath: string;
+  /** Variable name for imports */
+  variableName: string;
+  /** Route node type */
+  type: RouteNodeType;
+  /** Route name for vue-router */
+  routeName: string;
+  /** Is lazy-loaded */
+  isLazy: boolean;
+  /** Param names in route */
+  params: RouteParam[];
+  /** Parsed route info from SFC */
+  parsed: ParsedRoute;
+  /** Child route nodes */
+  children: RouteNode[];
+  /** Parent route node */
+  parent?: RouteNode;
+  /** Route group name (if inside group folder) */
+  group?: string;
+  /** Raw segment from filename */
+  rawSegment: string;
+  /** Source layer name (for layer-aware features) */
+  layer?: string;
+}
+/**
+ * Route parameter
+ */
+interface RouteParam {
+  /** Parameter name */
+  name: string;
+  /** Is optional param */
+  optional: boolean;
+  /** Is catch-all (splat) param */
+  isSplat: boolean;
+  /** Is repeatable (+) */
+  repeatable: boolean;
+}
+/**
+ * Parsed route definition from SFC
+ */
+interface ParsedRoute {
+  /** Route has a Route export */
+  hasRouteDefinition: boolean;
+  /** Route path from createFileRoute() */
+  routePath: string | null;
+  /** Loader function exists */
+  hasLoader: boolean;
+  /** Meta object exists */
+  hasMeta: boolean;
+  /** Search params validation exists */
+  hasValidateSearch: boolean;
+  /** Is this a layout file */
+  isLayout: boolean;
+  /** Raw route script content */
+  routeScriptContent: string | null;
+}
+/**
+ * Generated routes output
+ */
+interface GeneratedOutput {
+  /** routes.gen.ts content */
+  routesCode: string;
+  /** route-types.d.ts content */
+  typesCode: string;
+  /** Route tree */
+  routes: RouteNode[];
+}
+/**
+ * Route tree node for building
+ */
+interface TreeNode {
+  segment: string;
+  routePath: string;
+  node?: RouteNode;
+  children: Map<string, TreeNode>;
+  parent?: TreeNode;
+}
+//#endregion
+//#region src/plugin.d.ts
+/**
+ * Layer route configuration
+ */
+interface LayerRouteConfig {
+  /** Layer name */
+  layerName: string;
+  /** Routes directory path */
+  routesDir: string;
+  /** Layer root path (for generating .kimesh directory) */
+  layerPath?: string;
+  /** Base path prefix for routes */
+  basePath?: string;
+  /** Layer priority (lower = higher priority) */
+  priority: number;
+}
+interface KimeshRouterPluginOptions extends Partial<KimeshRouterConfig> {
+  /** Enable debug logging */
+  debug?: boolean;
+  /** Layer routes configuration (static) */
+  layerRoutes?: LayerRouteConfig[];
+  /** Layer routes configuration (lazy getter for async resolution) */
+  getLayerRoutes?: () => LayerRouteConfig[];
+}
+/**
+ * Kimesh Router Generator Vite Plugin
+ */
+declare function kimeshRouterGenerator(options?: KimeshRouterPluginOptions): Plugin;
+//#endregion
+//#region src/scanner.d.ts
+/**
+ * Route file scanner
+ * Scans the routes directory and builds route nodes
+ */
+declare class RouteScanner {
+  private config;
+  private routeNodes;
+  constructor(config: ResolvedRouterConfig);
+  /**
+       * Scan routes directory and return route nodes
+       */
+  scan(): Promise<RouteNode[]>;
+  /**
+       * Process a single route file
+       */
+  private processFile;
+  /**
+       * Parse filename to determine route type and path
+       *
+       * Kimesh file-based routing conventions:
+       * - __root.vue → root layout (wraps everything)
+       * - index.vue → index route
+       * - about.vue → regular page (/about)
+       * - $id.vue → dynamic param (/users/:id)
+       * - $.vue → catch-all (splat route)
+       * - _auth.vue → pathless layout (underscore prefix, no URL segment)
+       * - posts.vue + posts/ → layout route (file + matching directory)
+       * - posts.index.vue → flat route notation (dot separator)
+       */
+  private parseFileName;
+  private parseDotNotationRoute;
+  /**
+       * Generate a valid JavaScript variable name from file path
+       */
+  private generateVariableName;
+  /**
+       * Generate route name from route path
+       */
+  private generateRouteName;
+  /**
+       * Check if route should be lazy loaded based on config
+       */
+  private shouldBeLazy;
+  /**
+       * Get all scanned route nodes
+       */
+  getNodes(): RouteNode[];
+  /**
+       * Build glob pattern for file scanning based on configured extensions
+       */
+  private buildGlobPattern;
+}
+/**
+ * Create a route scanner instance
+ */
+declare function createScanner(config: ResolvedRouterConfig): RouteScanner;
+//#endregion
+//#region src/parser.d.ts
+/**
+ * Extended parsed route with OXC-extracted metadata
+ */
+interface ExtendedParsedRoute extends ParsedRoute {
+  /** defineLoader options if present */
+  loaderOptions?: {
+    isAsync: boolean;
+    hasBeforeLoad: boolean;
+    dependencies: string[];
+    cacheStrategy?: string;
+  };
+  /** defineMiddleware names */
+  middleware?: string[];
+  /** definePageMeta options */
+  pageMeta?: {
+    name?: string;
+    path?: string;
+    alias?: string | string[];
+    redirect?: string;
+    layout?: string | false;
+    transition?: boolean | string;
+    keepAlive?: boolean;
+    meta?: Record<string, unknown>;
+  };
+}
+/**
+ * Parse a Vue SFC file to extract route definition information using OXC
+ */
+declare function parseRouteFile(code: string, filePath: string): ExtendedParsedRoute;
+/**
+ * Create an empty parsed route
+ */
+declare function createEmptyParsedRoute(filePath: string): ExtendedParsedRoute;
+//#endregion
+//#region src/tree-builder.d.ts
+/**
+ * Build a route tree from flat route nodes
+ */
+declare class RouteTreeBuilder {
+  private config;
+  private root;
+  private layoutNodes;
+  private pathlessLayoutMap;
+  constructor(config: ResolvedRouterConfig);
+  /**
+       * Build route tree from scanned nodes
+       */
+  build(nodes: RouteNode[]): RouteNode[];
+  private separateLayoutsAndPages;
+  private registerLayout;
+  private groupPagesByPathlessLayout;
+  private findMatchingPathlessLayout;
+  private addPathlessLayoutRoutes;
+  /**
+       * Insert a node into the tree
+       */
+  private insertNode;
+  /**
+       * Get path segments from route path
+       */
+  private getPathSegments;
+  /**
+       * Create a tree node
+       */
+  private createTreeNode;
+  /**
+       * Flatten tree to route array
+       */
+  private flattenTree;
+  /**
+       * Flatten children of a tree node
+       */
+  private flattenChildren;
+  private flattenChildNode;
+  private createLayoutWithChildren;
+  private flattenNodeWithChildren;
+  /**
+       * Compare segments for sorting
+       * Order: static > dynamic > catch-all
+       */
+  private compareSegments;
+  /**
+       * Get sorting score for a segment
+       */
+  private getSegmentScore;
+}
+/**
+ * Create a route tree builder
+ */
+declare function createTreeBuilder(config: ResolvedRouterConfig): RouteTreeBuilder;
+/**
+ * Build route tree from nodes
+ */
+declare function buildRouteTree(nodes: RouteNode[], config: ResolvedRouterConfig): RouteNode[];
+//#endregion
+//#region src/codegen/routes.d.ts
+/**
+ * Generate routes.gen.ts content
+ */
+declare function generateRoutes(routes: RouteNode[], config: ResolvedRouterConfig): string;
+//#endregion
+//#region src/codegen/types.d.ts
+/**
+ * Generate typed-routes.d.ts content with comprehensive type safety
+ */
+declare function generateRouteTypes(routes: RouteNode[]): string;
+//#endregion
+//#region src/route-utils.d.ts
+interface ParsedFileName {
+  type: RouteNodeType;
+  routePath: string;
+  params: RouteParam[];
+  rawSegment: string;
+  isPathlessLayout?: boolean;
+}
+/**
+ * Check if directory path is root (empty or ".")
+ */
+declare function isRootDir(dirPath: string): boolean;
+/**
+ * Extract dynamic param name from segment (e.g., "$id" -> "id")
+ */
+declare function extractDynamicParam(segment: string): string | null;
+/**
+ * Check if filename uses dot notation for flat routes
+ */
+declare function isDotNotationRoute(fileName: string): boolean;
+/**
+ * Unescape bracket notation in filenames
+ * e.g., script[.]js -> script.js, api[.]v1 -> api.v1
+ */
+declare function unescapeBrackets(segment: string): string;
+/**
+ * Process a single path segment for dynamic params and special conventions
+ *
+ * Conventions:
+ * - (auth) -> pathless group folder, returns empty string
+ * - _auth -> pathless layout folder, returns empty string
+ * - posts_ -> layout escape, strips trailing underscore
+ * - $id -> dynamic param :id
+ * - -folder -> excluded from routing (dash prefix)
+ * - [x] -> escape special characters
+ */
+declare function processPathSegment(segment: string): string;
+/**
+ * Process directory path into route segments
+ */
+declare function processDirectoryPath(dirPath: string): string;
+/**
+ * Build route path from directory and segment
+ */
+declare function buildRoutePath(dirPath: string, segment: string): string;
+/**
+ * Create a standard RouteParam for a dynamic parameter
+ */
+declare function createDynamicParam(name: string): RouteParam;
+/**
+ * Create a catch-all RouteParam
+ */
+declare function createCatchAllParam(): RouteParam;
+/**
+ * Build a glob pattern for route file scanning
+ */
+declare function buildGlobPattern(extensions: string[]): string;
+//#endregion
+//#region src/layer-collector.d.ts
+/**
+ * Layer route source configuration
+ */
+interface LayerRouteSource {
+  /** Layer name */
+  layer: string;
+  /** Layer priority (0 = app/highest) */
+  priority: number;
+  /** Absolute path to routes directory */
+  routesDir: string;
+  /** Base path prefix for all routes in this layer */
+  basePath?: string;
+}
+/**
+ * Collected layer routes result
+ */
+interface LayerRoutesResult {
+  /** All route nodes from all layers */
+  routes: RouteNode[];
+  /** Routes grouped by layer */
+  byLayer: Map<string, RouteNode[]>;
+  /** Timing information */
+  timing: {
+    totalMs: number;
+    perLayer: Map<string, number>;
+  };
+}
+/**
+ * Extended route node with layer information
+ */
+interface LayerRouteNode extends RouteNode {
+  /** Source layer name */
+  layer: string;
+  /** Layer priority */
+  layerPriority: number;
+  /** Base path from layer config */
+  layerBasePath?: string;
+  /** Final route path (with basePath applied) */
+  finalRoutePath: string;
+}
+/**
+ * Collect routes from all configured layers and build proper route trees
+ */
+declare function collectLayerRoutes(sources: LayerRouteSource[], config: ResolvedRouterConfig): Promise<LayerRoutesResult>;
+//#endregion
+//#region src/layout-resolver.d.ts
+/**
+ * Resolved layout information
+ */
+interface ResolvedLayout {
+  /** Absolute file path */
+  filePath: string;
+  /** Layout name (undefined for default) */
+  name?: string;
+  /** Route path this layout applies to */
+  routePath: string;
+  /** Layer this layout comes from */
+  layer: string;
+  /** Layer priority */
+  priority: number;
+  /** Source type: 'host' or 'layer' */
+  source: 'host' | 'layer';
+  /** Mount path for layer layouts */
+  mountPath?: string;
+}
+/**
+ * Layout chain for a page
+ */
+interface LayoutChain {
+  /** Ordered list of layouts from outermost to innermost */
+  layouts: ResolvedLayout[];
+  /** Final page component */
+  page: LayerRouteNode;
+}
+/**
+ * Layout resolver for nested wrapping
+ *
+ * Key principle: Host layouts WRAP layer layouts (outer → inner)
+ * - Host root layout is always outermost
+ * - Host path-specific layouts come next
+ * - Layer layouts are innermost (closest to page content)
+ */
+declare class LayoutResolver {
+  private hostLayouts;
+  private layerLayouts;
+  private layerMounts;
+  /**
+       * Build layout chains for all routes
+       */
+  resolveLayoutChains(routes: LayerRouteNode[], layerMounts: Map<string, string>): Map<string, LayoutChain>;
+  /**
+       * Categorize layouts into host and layer layouts
+       */
+  private categorizeLayouts;
+  /**
+       * Build the complete layout chain for a page
+       *
+       * Order: Host root → Host path-specific → Layer root → Layer path-specific → Page
+       */
+  private buildLayoutChain;
+  /**
+       * Collect host layouts from root to most specific path
+       */
+  private collectHostLayouts;
+  /**
+       * Collect layer layouts from layer root to most specific path
+       */
+  private collectLayerLayouts;
+  /**
+       * Extract layout name from file path
+       * _layout.admin.vue → 'admin'
+       * _layout.vue → undefined
+       */
+  private extractLayoutName;
+  /**
+       * Make a unique key for layout lookup
+       */
+  private makeLayoutKey;
+}
+/**
+ * Generate nested layout component structure for Vue Router
+ *
+ * This generates the component tree where layouts wrap their children
+ */
+declare function generateLayoutStructure(chain: LayoutChain): {
+  component: string;
+  children?: any[];
+} | null;
+//#endregion
+export { type ExtendedParsedRoute, type GeneratedOutput, type KimeshRouterConfig, type KimeshRouterPluginOptions, type LayerRouteConfig, type LayerRouteNode, type LayerRouteSource, type LayerRoutesResult, type LayoutChain, LayoutResolver, type ParsedFileName, type ParsedRoute, type ResolvedLayout, type ResolvedRouterConfig, type RouteNode, type RouteNodeType, type RouteParam, RouteScanner, RouteTreeBuilder, type TreeNode, buildGlobPattern, buildRoutePath, buildRouteTree, collectLayerRoutes, createCatchAllParam, createDynamicParam, createEmptyParsedRoute, createScanner, createTreeBuilder, extractDynamicParam, generateLayoutStructure, generateRouteTypes, generateRoutes, isDotNotationRoute, isRootDir, kimeshRouterGenerator, parseRouteFile, processDirectoryPath, processPathSegment, unescapeBrackets };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/types.ts","../src/plugin.ts","../src/scanner.ts","../src/parser.ts","../src/tree-builder.ts","../src/codegen/routes.ts","../src/codegen/types.ts","../src/route-utils.ts","../src/layer-collector.ts","../src/layout-resolver.ts"],"mappings":"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"}