@ecopages/core 0.2.0-alpha.5 → 0.2.0-alpha.50

package/src/router/fs-router-scanner.ts

@@ -1,217 +0,0 @@
-import path from 'node:path';
-import { appLogger } from '../global/app-logger.ts';
-import type { EcoPagesAppConfig, RouteKind, Routes } from '../internal-types.ts';
-import type { EcoPageFile, GetStaticPaths } from '../public-types.ts';
-import { fileSystem } from '@ecopages/file-system';
-import { invariant } from '../utils/invariant.ts';
-import { existsSync } from 'node:fs';
-import { PageModuleImportService } from '../services/page-module-import.service.ts';
-
-type CreateRouteArgs = {
-	routePath: string;
-	filePath: string;
-	route: string;
-};
-
-type FSRouterScannerOptions = {
-	buildMode: boolean;
-};
-
-/**
- * @class FSRouterScanner
- * @description
- * This class is responsible for scanning the file system for routes.
- * It uses the glob package to scan the file system for files with the specified file extensions.
- * It then creates a map of the routes with the pathname as the key.
- * The pathname is the route without the file extension.
- * For example, if the file is "index.tsx", the pathname will be "/index".
- * If the file is "blog/[slug].tsx", the pathname will be "/blog/[slug]".
- * If the file is "blog/[...slug].tsx", the pathname will be "/blog/[...slug]".
- */
-export class FSRouterScanner {
-	private dir: string;
-	private origin = '';
-	private templatesExt: string[];
-	private options: FSRouterScannerOptions;
-	private appConfig: EcoPagesAppConfig;
-	routes: Routes = {};
-	private pageModuleImportService = new PageModuleImportService();
-
-	constructor({
-		dir,
-		origin,
-		templatesExt,
-		options,
-		appConfig,
-	}: {
-		dir: string;
-		origin: string;
-		templatesExt: string[];
-		options: FSRouterScannerOptions;
-		appConfig: EcoPagesAppConfig;
-	}) {
-		this.dir = dir;
-		this.origin = origin;
-		this.templatesExt = templatesExt;
-		this.options = options;
-		this.appConfig = appConfig;
-	}
-
-	private getRoutePath(path: string): string {
-		const cleanedRoute = this.templatesExt
-			.reduce((route, ext) => route.replace(ext, ''), path)
-			.replace(/\/?index$/, '');
-		return `/${cleanedRoute}`;
-	}
-
-	private getDynamicParamsNames(route: string): string[] {
-		const matches = route.match(/\[.*?\]/g);
-		return matches ? matches.map((match) => match.slice(1, -1)) : [];
-	}
-
-	private async getStaticPathsFromDynamicRoute({
-		route,
-		filePath,
-		getStaticPaths,
-	}: {
-		route: string;
-		filePath: string;
-		getStaticPaths: GetStaticPaths;
-	}): Promise<string[]> {
-		const staticPaths = await getStaticPaths({
-			appConfig: this.appConfig,
-			runtimeOrigin: this.origin,
-		});
-		return staticPaths.paths.map((path) => {
-			const dynamicParamsNames = this.getDynamicParamsNames(filePath);
-			let routeWithParams = route;
-
-			for (const param of dynamicParamsNames) {
-				routeWithParams = routeWithParams.replace(`[${param}]`, (path.params as Record<string, string>)[param]);
-			}
-
-			return routeWithParams;
-		});
-	}
-
-	private async createStaticRoutes({
-		filePath,
-		route,
-		routePath,
-		getStaticPaths,
-	}: CreateRouteArgs & { getStaticPaths: GetStaticPaths }): Promise<void> {
-		try {
-			const routesWithParams = await this.getStaticPathsFromDynamicRoute({
-				route,
-				filePath,
-				getStaticPaths,
-			});
-
-			for (const routeWithParams of routesWithParams) {
-				this.createRoute('dynamic', { filePath, route: routeWithParams, routePath });
-			}
-		} catch (error) {
-			appLogger.error(`[ecopages] Error creating static routes for ${filePath}: ${error}`);
-		}
-	}
-
-	private async handleDynamicRouteCreation({ filePath, route, routePath }: CreateRouteArgs): Promise<void> {
-		const module = (await this.importPageModule(filePath)) as EcoPageFile;
-		const Page = module.default;
-
-		/**
-		 * Check for attached static functions (consolidated API) or named exports (legacy)
-		 */
-		const getStaticPaths = Page?.staticPaths ?? module.getStaticPaths;
-		const getStaticProps = Page?.staticProps ?? module.getStaticProps;
-
-		if (this.options.buildMode) {
-			invariant(getStaticProps !== undefined, `[ecopages] Missing getStaticProps in ${filePath}`);
-			invariant(getStaticPaths !== undefined, `[ecopages] Missing getStaticPaths in ${filePath}`);
-		}
-
-		if (getStaticPaths) {
-			return this.createStaticRoutes({
-				filePath,
-				route,
-				routePath,
-				getStaticPaths,
-			});
-		}
-
-		return this.createRoute('dynamic', { filePath, route, routePath });
-	}
-
-	private async importPageModule(filePath: string): Promise<unknown> {
-		return this.pageModuleImportService.importModule({
-			filePath,
-			rootDir: this.appConfig.rootDir,
-			outdir: path.join(this.appConfig.absolutePaths.distDir, '.server-route-modules'),
-			externalPackages: false,
-			transpileErrorMessage: (details) => `Error transpiling route module: ${details}`,
-			noOutputMessage: (targetFilePath) => `No transpiled output generated for route module: ${targetFilePath}`,
-		});
-	}
-
-	private createRoute(kind: RouteKind, { filePath, route, routePath }: CreateRouteArgs): void {
-		this.routes[route] = {
-			kind,
-			pathname: routePath,
-			filePath,
-		};
-	}
-
-	private getRouteData(file: string): CreateRouteArgs & {
-		kind: RouteKind;
-	} {
-		const routePath = this.getRoutePath(file);
-		const route = `${this.origin}${routePath}`;
-		const filePath = path.join(this.dir, file);
-		const isCatchAll = filePath.includes('[...');
-		const isDynamic = !isCatchAll && filePath.includes('[') && filePath.includes(']');
-		const kind: RouteKind = isCatchAll ? 'catch-all' : isDynamic ? 'dynamic' : 'exact';
-
-		return { route, routePath, filePath, kind };
-	}
-
-	async scan(): Promise<Routes> {
-		this.routes = {};
-
-		if (!existsSync(this.dir)) {
-			return this.routes;
-		}
-
-		const scannedFiles = await fileSystem.glob(
-			this.templatesExt.map((ext) => `**/*${ext}`),
-			{ cwd: this.dir },
-		);
-
-		for await (const file of scannedFiles) {
-			if (file.includes('.ecopages-node.')) {
-				continue;
-			}
-
-			const { kind, ...routeData } = this.getRouteData(file);
-
-			switch (kind) {
-				case 'dynamic':
-					await this.handleDynamicRouteCreation(routeData);
-					break;
-				case 'catch-all':
-					if (this.options.buildMode) {
-						appLogger.warn(
-							'Catch-all routes are not supported in static generation, they will not be included in the bundle\n',
-							`➤ ${routeData.filePath}`,
-						);
-					}
-					this.createRoute(kind, routeData);
-					break;
-				default:
-					this.createRoute(kind, routeData);
-					break;
-			}
-		}
-
-		return this.routes;
-	}
-}

package/src/router/fs-router.d.ts

@@ -1,26 +0,0 @@
-import type { MatchResult, Route, Routes } from '../internal-types.js';
-import type { FSRouterScanner } from './fs-router-scanner.js';
-/**
- * A class that manages the routes of the file system.
- * It scans the file system for files with the specified extensions and creates a map of routes.
- * It also provides a method to match a request to a route.
- * It can be used to reload the routes when the file system changes.
- */
-export declare class FSRouter {
-    origin: string;
-    assetPrefix: string;
-    routes: Routes;
-    scanner: FSRouterScanner;
-    onReload?: () => void;
-    constructor({ origin, assetPrefix, scanner }: {
-        origin: string;
-        assetPrefix: string;
-        scanner: FSRouterScanner;
-    });
-    init(): Promise<void>;
-    getDynamicParams(route: Route, pathname: string): Record<string, string | string[]>;
-    getSearchParams(url: URL): Record<string, string>;
-    match(requestUrl: string): MatchResult | null;
-    setOnReload(cb: () => void): void;
-    reload(): void;
-}

package/src/router/fs-router.js

@@ -1,100 +0,0 @@
-import { appLogger } from "../global/app-logger.js";
-class FSRouter {
-  origin;
-  assetPrefix;
-  routes = {};
-  scanner;
-  onReload;
-  constructor({ origin, assetPrefix, scanner }) {
-    this.origin = origin;
-    this.assetPrefix = assetPrefix;
-    this.scanner = scanner;
-  }
-  async init() {
-    this.routes = await this.scanner.scan();
-    appLogger.debug("FSRouter initialized", this.routes);
-  }
-  getDynamicParams(route, pathname) {
-    const params = {};
-    const routeParts = route.pathname.split("/");
-    const pathnameParts = pathname.split("/");
-    for (let i = 0; i < routeParts.length; i++) {
-      const part = routeParts[i];
-      if (part.startsWith("[") && part.endsWith("]")) {
-        if (part.startsWith("[...")) {
-          const param2 = part.slice(4, -1);
-          params[param2] = pathnameParts.slice(i);
-          break;
-        }
-        const param = part.slice(1, -1);
-        params[param] = pathnameParts[i];
-      }
-    }
-    return params;
-  }
-  getSearchParams(url) {
-    const query = {};
-    for (const [key, value] of url.searchParams) {
-      query[key] = value;
-    }
-    return query;
-  }
-  match(requestUrl) {
-    const url = new URL(requestUrl);
-    const pathname = url.pathname.replace(this.origin, "");
-    const routeValues = Object.values(this.routes);
-    for (const route of routeValues) {
-      if (route.kind === "exact" && (pathname === route.pathname || pathname === `${route.pathname}/`)) {
-        return {
-          filePath: route.filePath,
-          kind: "exact",
-          pathname: route.pathname,
-          query: this.getSearchParams(url)
-        };
-      }
-    }
-    for (const route of routeValues) {
-      const cleanPathname = route.pathname.replace(/\[.*?\]/g, "");
-      const isValidDynamicRoute = pathname.includes(cleanPathname);
-      if (route.kind === "dynamic" && isValidDynamicRoute) {
-        const routeParts = route.pathname.split("/");
-        const pathnameParts = pathname.split("/");
-        if (routeParts.length === pathnameParts.length) {
-          return {
-            filePath: route.filePath,
-            kind: "dynamic",
-            pathname,
-            query: this.getSearchParams(url),
-            params: this.getDynamicParams(route, pathname)
-          };
-        }
-      }
-    }
-    for (const route of routeValues) {
-      const cleanPathname = route.pathname.replace(/\[.*?\]/g, "");
-      const isValidCatchAllRoute = pathname.includes(cleanPathname);
-      if (route.kind === "catch-all" && isValidCatchAllRoute) {
-        return {
-          filePath: route.filePath,
-          kind: "catch-all",
-          pathname,
-          query: this.getSearchParams(url),
-          params: this.getDynamicParams(route, pathname)
-        };
-      }
-    }
-    return null;
-  }
-  setOnReload(cb) {
-    this.onReload = cb;
-  }
-  reload() {
-    this.init();
-    if (this.onReload) {
-      this.onReload();
-    }
-  }
-}
-export {
-  FSRouter
-};

package/src/router/fs-router.ts

@@ -1,122 +0,0 @@
-import { appLogger } from '../global/app-logger.ts';
-import type { MatchResult, Route, Routes } from '../internal-types.ts';
-import type { FSRouterScanner } from './fs-router-scanner.ts';
-
-/**
- * A class that manages the routes of the file system.
- * It scans the file system for files with the specified extensions and creates a map of routes.
- * It also provides a method to match a request to a route.
- * It can be used to reload the routes when the file system changes.
- */
-export class FSRouter {
-	origin: string;
-	assetPrefix: string;
-	routes: Routes = {};
-	scanner: FSRouterScanner;
-	onReload?: () => void;
-
-	constructor({ origin, assetPrefix, scanner }: { origin: string; assetPrefix: string; scanner: FSRouterScanner }) {
-		this.origin = origin;
-		this.assetPrefix = assetPrefix;
-		this.scanner = scanner;
-	}
-
-	async init() {
-		this.routes = await this.scanner.scan();
-		appLogger.debug('FSRouter initialized', this.routes);
-	}
-
-	getDynamicParams(route: Route, pathname: string): Record<string, string | string[]> {
-		const params: Record<string, string | string[]> = {};
-		const routeParts = route.pathname.split('/');
-		const pathnameParts = pathname.split('/');
-
-		for (let i = 0; i < routeParts.length; i++) {
-			const part = routeParts[i];
-			if (part.startsWith('[') && part.endsWith(']')) {
-				if (part.startsWith('[...')) {
-					const param = part.slice(4, -1);
-					params[param] = pathnameParts.slice(i);
-					break;
-				}
-				const param = part.slice(1, -1);
-				params[param] = pathnameParts[i];
-			}
-		}
-		return params;
-	}
-
-	getSearchParams(url: URL): Record<string, string> {
-		const query: Record<string, string> = {};
-		for (const [key, value] of url.searchParams) {
-			query[key] = value;
-		}
-		return query;
-	}
-
-	match(requestUrl: string): MatchResult | null {
-		const url = new URL(requestUrl);
-		const pathname = url.pathname.replace(this.origin, '');
-
-		const routeValues = Object.values(this.routes);
-
-		for (const route of routeValues) {
-			if (route.kind === 'exact' && (pathname === route.pathname || pathname === `${route.pathname}/`)) {
-				return {
-					filePath: route.filePath,
-					kind: 'exact',
-					pathname: route.pathname,
-					query: this.getSearchParams(url),
-				};
-			}
-		}
-
-		for (const route of routeValues) {
-			const cleanPathname = route.pathname.replace(/\[.*?\]/g, '');
-			const isValidDynamicRoute = pathname.includes(cleanPathname);
-
-			if (route.kind === 'dynamic' && isValidDynamicRoute) {
-				const routeParts = route.pathname.split('/');
-				const pathnameParts = pathname.split('/');
-
-				if (routeParts.length === pathnameParts.length) {
-					return {
-						filePath: route.filePath,
-						kind: 'dynamic',
-						pathname: pathname,
-						query: this.getSearchParams(url),
-						params: this.getDynamicParams(route, pathname),
-					};
-				}
-			}
-		}
-
-		for (const route of routeValues) {
-			const cleanPathname = route.pathname.replace(/\[.*?\]/g, '');
-			const isValidCatchAllRoute = pathname.includes(cleanPathname);
-
-			if (route.kind === 'catch-all' && isValidCatchAllRoute) {
-				return {
-					filePath: route.filePath,
-					kind: 'catch-all',
-					pathname: pathname,
-					query: this.getSearchParams(url),
-					params: this.getDynamicParams(route, pathname),
-				};
-			}
-		}
-
-		return null;
-	}
-
-	setOnReload(cb: () => void) {
-		this.onReload = cb;
-	}
-
-	reload() {
-		this.init();
-		if (this.onReload) {
-			this.onReload();
-		}
-	}
-}

package/src/services/asset-processing-service/asset-processing.service.d.ts

@@ -1,41 +0,0 @@
-import type { EcoPagesAppConfig, IHmrManager } from '../../internal-types';
-import type { AssetDefinition, AssetKind, AssetSource, ProcessedAsset } from './assets.types';
-import { ProcessorRegistry } from './processor.registry';
-export declare class AssetProcessingService {
-    private readonly config;
-    static readonly RESOLVED_ASSETS_DIR = "assets";
-    private registry;
-    private hmrManager?;
-    private cache;
-    constructor(config: EcoPagesAppConfig);
-    /**
-     * Set the HMR manager for the asset processing service.
-     * @param hmrManager The HMR manager to set.
-     */
-    setHmrManager(hmrManager: IHmrManager): void;
-    getHmrManager(): IHmrManager | undefined;
-    /**
-     * Register a processor for a specific asset kind and source.
-     * @param kind The asset kind.
-     * @param variant The asset source.
-     * @param processor The processor to register.
-     */
-    registerProcessor(kind: AssetKind, variant: AssetSource, processor: any): void;
-    processDependencies(deps: AssetDefinition[], key: string): Promise<ProcessedAsset[]>;
-    private deduplicateDependencies;
-    private getScriptDependencyBuildSignature;
-    private getDependencyKey;
-    private generateHash;
-    private processDependenciesParallel;
-    private groupDependenciesByType;
-    private getSrcUrl;
-    private resolveProcessedAssetSrcUrl;
-    private isFilesystemPath;
-    private optimizeDependencies;
-    private getCachedAsset;
-    private setCachedAsset;
-    clearCache(): void;
-    invalidateCacheForFile(filepath: string): void;
-    static createWithDefaultProcessors(appConfig: EcoPagesAppConfig): AssetProcessingService;
-    getRegistry(): ProcessorRegistry;
-}