@ecopages/core 0.2.0-alpha.26 → 0.2.0-alpha.27

package/src/router/server/fs-router-scanner.js

@@ -1,161 +0,0 @@
-import path from "node:path";
-import { appLogger } from "../../global/app-logger.js";
-import { fileSystem } from "@ecopages/file-system";
-import { invariant } from "../../utils/invariant.js";
-import { existsSync } from "node:fs";
-import { getAppServerModuleTranspiler } from "../../services/module-loading/app-server-module-transpiler.service.js";
-import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
-class FSRouterScanner {
-  dir;
-  origin = "";
-  templatesExt;
-  options;
-  appConfig;
-  routes = {};
-  serverModuleTranspiler;
-  constructor({
-    dir,
-    origin,
-    templatesExt,
-    options,
-    appConfig
-  }) {
-    this.dir = dir;
-    this.origin = origin;
-    this.templatesExt = templatesExt;
-    this.options = options;
-    this.appConfig = appConfig;
-    this.serverModuleTranspiler = getAppServerModuleTranspiler(appConfig);
-  }
-  getRoutePath(path2) {
-    const cleanedRoute = this.templatesExt.reduce((route, ext) => route.replace(ext, ""), path2).replace(/\/?index$/, "");
-    return `/${cleanedRoute}`;
-  }
-  getDynamicParamsNames(route) {
-    const matches = route.match(/\[.*?\]/g);
-    return matches ? matches.map((match) => match.slice(1, -1)) : [];
-  }
-  async getStaticPathsFromDynamicRoute({
-    route,
-    filePath,
-    getStaticPaths
-  }) {
-    const staticPaths = await getStaticPaths({
-      appConfig: this.appConfig,
-      runtimeOrigin: this.origin
-    });
-    return staticPaths.paths.map((path2) => {
-      const dynamicParamsNames = this.getDynamicParamsNames(filePath);
-      let routeWithParams = route;
-      for (const param of dynamicParamsNames) {
-        routeWithParams = routeWithParams.replace(`[${param}]`, path2.params[param]);
-      }
-      return routeWithParams;
-    });
-  }
-  async createStaticRoutes({
-    filePath,
-    route,
-    routePath,
-    getStaticPaths
-  }) {
-    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}`);
-    }
-  }
-  async handleDynamicRouteCreation({ filePath, route, routePath }) {
-    const module = await this.importPageModule(filePath);
-    const Page = module.default;
-    const getStaticPaths = Page?.staticPaths ?? module.getStaticPaths;
-    const getStaticProps = Page?.staticProps ?? module.getStaticProps;
-    if (this.options.buildMode) {
-      invariant(getStaticProps !== void 0, `[ecopages] Missing getStaticProps in ${filePath}`);
-      invariant(getStaticPaths !== void 0, `[ecopages] Missing getStaticPaths in ${filePath}`);
-    }
-    if (getStaticPaths) {
-      return this.createStaticRoutes({
-        filePath,
-        route,
-        routePath,
-        getStaticPaths
-      });
-    }
-    return this.createRoute("dynamic", { filePath, route, routePath });
-  }
-  async importPageModule(filePath) {
-    return this.serverModuleTranspiler.importModule({
-      filePath,
-      outdir: path.join(resolveInternalExecutionDir(this.appConfig), ".server-route-modules"),
-      externalPackages: false,
-      transpileErrorMessage: (details) => `Error transpiling route module: ${details}`,
-      noOutputMessage: (targetFilePath) => `No transpiled output generated for route module: ${targetFilePath}`
-    });
-  }
-  createRoute(kind, { filePath, route, routePath }) {
-    this.routes[route] = {
-      kind,
-      pathname: routePath,
-      filePath
-    };
-  }
-  getRouteData(file) {
-    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("]");
-    let kind = "exact";
-    if (isCatchAll) {
-      kind = "catch-all";
-    } else if (isDynamic) {
-      kind = "dynamic";
-    }
-    return { route, routePath, filePath, kind };
-  }
-  async scan() {
-    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",
-              `\u27A4 ${routeData.filePath}`
-            );
-          }
-          this.createRoute(kind, routeData);
-          break;
-        default:
-          this.createRoute(kind, routeData);
-          break;
-      }
-    }
-    return this.routes;
-  }
-}
-export {
-  FSRouterScanner
-};

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

@@ -1,26 +0,0 @@
-import type { MatchResult, Route, Routes } from '../../types/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/server/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/services/assets/asset-processing-service/asset-dependency-keys.d.ts

@@ -1,3 +0,0 @@
-import type { AssetDefinition } from './assets.types.js';
-export declare function getAssetDependencyKey(dep: AssetDefinition): string;
-export declare function deduplicateAssetDependencies(deps: AssetDefinition[]): AssetDefinition[];

package/src/services/assets/asset-processing-service/asset-dependency-keys.js

@@ -1,56 +0,0 @@
-import { rapidhash } from "../../../utils/hash.js";
-function generateHash(content) {
-  return rapidhash(content).toString();
-}
-function getScriptDependencyBuildSignature(dep) {
-  if (dep.kind !== "script") {
-    return void 0;
-  }
-  const pluginNames = dep.bundleOptions?.plugins?.map((plugin) => plugin.name) ?? [];
-  const signature = {
-    bundle: dep.bundle,
-    inline: dep.inline,
-    excludeFromHtml: dep.excludeFromHtml,
-    groupedBundle: dep.groupedBundle,
-    naming: dep.bundleOptions?.naming,
-    external: dep.bundleOptions?.external,
-    minify: dep.bundleOptions?.minify,
-    plugins: pluginNames
-  };
-  return generateHash(JSON.stringify(signature));
-}
-function getAssetDependencyKey(dep) {
-  const parts = [dep.kind, dep.source];
-  if ("filepath" in dep) {
-    parts.push(dep.filepath);
-  } else if ("content" in dep) {
-    parts.push(`content:${generateHash(dep.content)}`);
-  } else if ("importPath" in dep) {
-    parts.push(dep.importPath);
-  }
-  if ("position" in dep && dep.position) {
-    parts.push(dep.position);
-  }
-  if ("packageRole" in dep && dep.packageRole) {
-    parts.push(`package:${dep.packageRole}`);
-  }
-  const scriptBuildSignature = getScriptDependencyBuildSignature(dep);
-  if (scriptBuildSignature) {
-    parts.push(`build:${scriptBuildSignature}`);
-  }
-  return parts.join(":");
-}
-function deduplicateAssetDependencies(deps) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const dep of deps) {
-    const key = getAssetDependencyKey(dep);
-    if (!seen.has(key)) {
-      seen.set(key, dep);
-    }
-  }
-  return Array.from(seen.values());
-}
-export {
-  deduplicateAssetDependencies,
-  getAssetDependencyKey
-};

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

@@ -1,103 +0,0 @@
-import type { EcoPagesAppConfig, IHmrManager } from '../../../types/internal-types.js';
-import type { AssetDefinition, AssetKind, AssetSource, ProcessedAsset } from './assets.types.js';
-import { ProcessorRegistry } from './processor.registry.js';
-/**
- * Processes declared component and page asset dependencies for one app instance.
- *
- * @remarks
- * This service is the shared bridge between dependency declarations and emitted
- * runtime-ready assets. It owns deduplication, processor dispatch, cache reuse,
- * output URL normalization, and production gzip preparation so route rendering
- * and HMR flows do not need to understand processor-specific behavior.
- */
-export declare class AssetProcessingService {
-    static readonly RESOLVED_ASSETS_DIR = "assets";
-    private registry;
-    private hmrManager?;
-    private cache;
-    private readonly config;
-    /**
-     * Creates the asset-processing service bound to one finalized app config.
-     */
-    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;
-    /**
-     * Processes one dependency list into normalized emitted assets.
-     *
-     * @remarks
-     * Dependencies are deduplicated before processor execution so repeated
-     * declarations across the render tree reuse the same emitted outputs and cache
-     * entries.
-     */
-    processDependencies(deps: AssetDefinition[], key: string): Promise<ProcessedAsset[]>;
-    /**
-     * Processes deduplicated dependencies grouped by processor type.
-     *
-     * @remarks
-     * Grouping keeps cache and processor behavior isolated by asset kind/source
-     * pair, while still allowing the overall dependency set to resolve in
-     * parallel.
-     */
-    private processDependenciesParallel;
-    /**
-     * Groups dependencies by processor bucket.
-     */
-    private groupDependenciesByType;
-    /**
-     * Converts a dist-local file path into its public URL.
-     */
-    private getSrcUrl;
-    /**
-     * Normalizes the public source URL for one processed asset.
-     */
-    private resolveProcessedAssetSrcUrl;
-    /**
-     * Returns whether a value should be interpreted as a filesystem path instead
-     * of an already-public URL.
-     */
-    private isFilesystemPath;
-    /**
-     * Applies post-processing for emitted production assets.
-     *
-     * @remarks
-     * Current optimization is intentionally conservative: only generated CSS and
-     * JavaScript files inside the app dist directory are gzipped.
-     */
-    private optimizeDependencies;
-    /**
-     * Returns the cached processed asset for a dependency key when available.
-     */
-    private getCachedAsset;
-    /**
-     * Stores one processed asset in the dependency cache.
-     */
-    private setCachedAsset;
-    /**
-     * Clears all cached processed assets.
-     */
-    clearCache(): void;
-    /**
-     * Removes cached assets that were produced from the given file path.
-     */
-    invalidateCacheForFile(filepath: string): void;
-    /**
-     * Creates a service prewired with the default core processors.
-     */
-    static createWithDefaultProcessors(appConfig: EcoPagesAppConfig): AssetProcessingService;
-    /**
-     * Returns the processor registry owned by this service.
-     */
-    getRegistry(): ProcessorRegistry;
-}