@ecopages/core 0.2.0-alpha.4 → 0.2.0-alpha.6

package/src/services/asset-processing-service/asset-processing.service.js

@@ -1,250 +0,0 @@
-import path from "node:path";
-import { RESOLVED_ASSETS_DIR } from "../../constants";
-import { appLogger } from "../../global/app-logger";
-import { rapidhash } from "../../utils/hash";
-import { fileSystem } from "@ecopages/file-system";
-import { isHmrAware } from "./processor.interface";
-import { ProcessorRegistry } from "./processor.registry";
-import {
-  ContentScriptProcessor,
-  ContentStylesheetProcessor,
-  FileScriptProcessor,
-  FileStylesheetProcessor,
-  NodeModuleScriptProcessor
-} from "./processors";
-class AssetProcessingService {
-  constructor(config) {
-    this.config = config;
-  }
-  static RESOLVED_ASSETS_DIR = RESOLVED_ASSETS_DIR;
-  registry = new ProcessorRegistry();
-  hmrManager;
-  cache = /* @__PURE__ */ new Map();
-  /**
-   * Set the HMR manager for the asset processing service.
-   * @param hmrManager The HMR manager to set.
-   */
-  setHmrManager(hmrManager) {
-    this.hmrManager = hmrManager;
-    for (const processor of this.registry.getAllProcessors().values()) {
-      if (isHmrAware(processor)) {
-        processor.setHmrManager(hmrManager);
-      }
-    }
-  }
-  getHmrManager() {
-    return this.hmrManager;
-  }
-  /**
-   * 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, variant, processor) {
-    if (this.hmrManager && isHmrAware(processor)) {
-      processor.setHmrManager(this.hmrManager);
-    }
-    this.registry.register(kind, variant, processor);
-  }
-  async processDependencies(deps, key) {
-    const depsDir = path.join(this.config.absolutePaths.distDir, RESOLVED_ASSETS_DIR);
-    fileSystem.ensureDir(depsDir);
-    const dedupedDeps = this.deduplicateDependencies(deps);
-    const results = await this.processDependenciesParallel(dedupedDeps, key);
-    await this.optimizeDependencies(results);
-    return results;
-  }
-  deduplicateDependencies(deps) {
-    const seen = /* @__PURE__ */ new Map();
-    for (const dep of deps) {
-      const key = this.getDependencyKey(dep);
-      if (!seen.has(key)) {
-        seen.set(key, dep);
-      }
-    }
-    return Array.from(seen.values());
-  }
-  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,
-      naming: dep.bundleOptions?.naming,
-      external: dep.bundleOptions?.external,
-      minify: dep.bundleOptions?.minify,
-      plugins: pluginNames
-    };
-    return this.generateHash(JSON.stringify(signature));
-  }
-  getDependencyKey(dep) {
-    const parts = [dep.kind, dep.source];
-    if ("filepath" in dep) {
-      parts.push(dep.filepath);
-    } else if ("content" in dep) {
-      parts.push(`content:${this.generateHash(dep.content)}`);
-    } else if ("importPath" in dep) {
-      parts.push(dep.importPath);
-    }
-    if ("position" in dep && dep.position) {
-      parts.push(dep.position);
-    }
-    const scriptBuildSignature = this.getScriptDependencyBuildSignature(dep);
-    if (scriptBuildSignature) {
-      parts.push(`build:${scriptBuildSignature}`);
-    }
-    return parts.join(":");
-  }
-  generateHash(content) {
-    return rapidhash(content).toString();
-  }
-  async processDependenciesParallel(deps, key) {
-    const grouped = this.groupDependenciesByType(deps);
-    const groupPromises = Object.entries(grouped).map(async ([, typeDeps]) => {
-      const typePromises = typeDeps.map(async (dep) => {
-        const depKey = this.getDependencyKey(dep);
-        const cached = this.getCachedAsset(dep, depKey);
-        if (cached) {
-          return { key, ...cached };
-        }
-        const processor = this.registry.getProcessor(dep.kind, dep.source);
-        if (!processor) {
-          appLogger.error(`No processor found for ${dep.kind}/${dep.source}`);
-          return null;
-        }
-        if (dep.source === "file" && "filepath" in dep) {
-          const fileExists = fileSystem.exists(dep.filepath);
-          if (!fileExists) {
-            appLogger.warn(`Skipping missing ${dep.kind} file: ${dep.filepath}`);
-            return null;
-          }
-        }
-        try {
-          const processed = await processor.process(dep);
-          const srcUrl = this.resolveProcessedAssetSrcUrl(processed);
-          const processedWithKey = {
-            key,
-            ...processed,
-            srcUrl
-          };
-          this.setCachedAsset(dep, depKey, processedWithKey);
-          return processedWithKey;
-        } catch (error) {
-          appLogger.error(
-            `Failed to process dependency: ${error instanceof Error ? error.message : String(error)} for ${dep.kind}/${dep.source}`
-          );
-          appLogger.debug(error);
-          return null;
-        }
-      });
-      const typeResults = await Promise.all(typePromises);
-      return typeResults.filter((result) => result !== null);
-    });
-    const allTypeResults = await Promise.all(groupPromises);
-    return allTypeResults.flat();
-  }
-  groupDependenciesByType(deps) {
-    return deps.reduce(
-      (acc, dep) => {
-        const key = `${dep.kind}_${dep.source}`;
-        if (!acc[key]) acc[key] = [];
-        acc[key].push(dep);
-        return acc;
-      },
-      {}
-    );
-  }
-  getSrcUrl(filepath) {
-    const distDir = this.config.absolutePaths.distDir;
-    if (!filepath.startsWith(distDir)) return void 0;
-    const relativePath = filepath.slice(distDir.length);
-    const urlPath = relativePath.startsWith("/") ? relativePath : `/${relativePath}`;
-    return urlPath.replace(/\\/g, "/");
-  }
-  resolveProcessedAssetSrcUrl(processed) {
-    if (processed.srcUrl) {
-      if (this.isFilesystemPath(processed.srcUrl)) {
-        const srcUrlFromPath = this.getSrcUrl(processed.srcUrl);
-        if (srcUrlFromPath) return srcUrlFromPath;
-      } else {
-        return processed.srcUrl;
-      }
-    }
-    if (processed.filepath) {
-      return this.getSrcUrl(processed.filepath);
-    }
-    return void 0;
-  }
-  isFilesystemPath(value) {
-    if (value.startsWith("http://") || value.startsWith("https://") || value.startsWith("//")) {
-      return false;
-    }
-    if (value.startsWith(this.config.absolutePaths.distDir)) {
-      return true;
-    }
-    const rootDir = this.config.rootDir;
-    if (rootDir && value.startsWith(rootDir)) {
-      return true;
-    }
-    return /^[A-Za-z]:\\/.test(value);
-  }
-  async optimizeDependencies(processedAssets) {
-    if (process.env.NODE_ENV !== "production") {
-      return;
-    }
-    const filesToGzip = /* @__PURE__ */ new Set();
-    for (const asset of processedAssets) {
-      if (!asset.filepath) {
-        continue;
-      }
-      if (!asset.filepath.startsWith(this.config.absolutePaths.distDir)) {
-        continue;
-      }
-      const extension = path.extname(asset.filepath).slice(1);
-      if (extension === "css" || extension === "js") {
-        filesToGzip.add(asset.filepath);
-      }
-    }
-    for (const filePath of filesToGzip) {
-      if (fileSystem.exists(filePath)) {
-        fileSystem.gzipFile(filePath);
-      }
-    }
-  }
-  getCachedAsset(dep, depKey) {
-    const cached = this.cache.get(depKey);
-    return cached?.asset ?? null;
-  }
-  setCachedAsset(dep, depKey, asset) {
-    this.cache.set(depKey, { asset });
-  }
-  clearCache() {
-    this.cache.clear();
-  }
-  invalidateCacheForFile(filepath) {
-    for (const [key, value] of this.cache.entries()) {
-      if (value.asset.filepath === filepath) {
-        this.cache.delete(key);
-      }
-    }
-  }
-  static createWithDefaultProcessors(appConfig) {
-    const service = new AssetProcessingService(appConfig);
-    service.registerProcessor("script", "content", new ContentScriptProcessor({ appConfig }));
-    service.registerProcessor("script", "file", new FileScriptProcessor({ appConfig }));
-    service.registerProcessor("script", "node-module", new NodeModuleScriptProcessor({ appConfig }));
-    service.registerProcessor("stylesheet", "content", new ContentStylesheetProcessor({ appConfig }));
-    service.registerProcessor("stylesheet", "file", new FileStylesheetProcessor({ appConfig }));
-    return service;
-  }
-  getRegistry() {
-    return this.registry;
-  }
-}
-export {
-  AssetProcessingService
-};

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

@@ -1,17 +0,0 @@
-import type { ContentScriptAsset, ContentStylesheetAsset, FileScriptAsset, FileStylesheetAsset, InlineContentScriptAsset, InlineContentStylesheetAsset, InlineFileScriptAsset, JsonScriptAsset, NodeModuleScriptAsset } from './assets.types';
-type CreateAssetOptions<T> = Omit<T, 'kind' | 'source' | 'inline'>;
-export declare class AssetFactory {
-    static readonly RESOLVED_ASSETS_DIR = "assets";
-    static readonly RESOLVED_ASSETS_VENDORS_DIR: string;
-    static createContentScript(options: CreateAssetOptions<ContentScriptAsset>): ContentScriptAsset;
-    static createInlineContentScript(options: CreateAssetOptions<InlineContentScriptAsset>): InlineContentScriptAsset;
-    static createFileScript(options: CreateAssetOptions<FileScriptAsset>): FileScriptAsset;
-    static createInlineFileScript(options: CreateAssetOptions<InlineFileScriptAsset>): InlineFileScriptAsset;
-    static createNodeModuleScript(options: CreateAssetOptions<NodeModuleScriptAsset>): NodeModuleScriptAsset;
-    static createInlineNodeModuleScript(options: CreateAssetOptions<NodeModuleScriptAsset>): NodeModuleScriptAsset;
-    static createJsonScript(options: CreateAssetOptions<JsonScriptAsset>): JsonScriptAsset;
-    static createContentStylesheet(options: CreateAssetOptions<ContentStylesheetAsset>): ContentStylesheetAsset;
-    static createInlineContentStylesheet(options: CreateAssetOptions<InlineContentStylesheetAsset>): InlineContentStylesheetAsset;
-    static createFileStylesheet(options: CreateAssetOptions<FileStylesheetAsset>): FileStylesheetAsset;
-}
-export {};

package/src/services/asset-processing-service/asset.factory.js

@@ -1,82 +0,0 @@
-import { RESOLVED_ASSETS_DIR, RESOLVED_ASSETS_VENDORS_DIR } from "../../constants";
-import { deepMerge } from "../../utils/deep-merge";
-class AssetFactory {
-  static RESOLVED_ASSETS_DIR = RESOLVED_ASSETS_DIR;
-  static RESOLVED_ASSETS_VENDORS_DIR = RESOLVED_ASSETS_VENDORS_DIR;
-  static createContentScript(options) {
-    return {
-      kind: "script",
-      source: "content",
-      position: options.position || "body",
-      ...options
-    };
-  }
-  static createInlineContentScript(options) {
-    return {
-      ...AssetFactory.createContentScript(options),
-      inline: true
-    };
-  }
-  static createFileScript(options) {
-    return {
-      kind: "script",
-      source: "file",
-      position: options.position || "body",
-      ...options
-    };
-  }
-  static createInlineFileScript(options) {
-    return {
-      ...AssetFactory.createFileScript(options),
-      inline: true
-    };
-  }
-  static createNodeModuleScript(options) {
-    return {
-      kind: "script",
-      source: "node-module",
-      position: options.position || "body",
-      ...options
-    };
-  }
-  static createInlineNodeModuleScript(options) {
-    return {
-      ...AssetFactory.createNodeModuleScript(options),
-      inline: true
-    };
-  }
-  static createJsonScript(options) {
-    return {
-      kind: "script",
-      source: "content",
-      attributes: deepMerge(options.attributes, { type: "application/json" }),
-      position: options.position || "body",
-      ...options
-    };
-  }
-  static createContentStylesheet(options) {
-    return {
-      kind: "stylesheet",
-      source: "content",
-      position: "head",
-      ...options
-    };
-  }
-  static createInlineContentStylesheet(options) {
-    return {
-      ...AssetFactory.createContentStylesheet(options),
-      inline: true
-    };
-  }
-  static createFileStylesheet(options) {
-    return {
-      kind: "stylesheet",
-      source: "file",
-      position: options.position || "head",
-      ...options
-    };
-  }
-}
-export {
-  AssetFactory
-};

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

@@ -1,88 +0,0 @@
-import type { EcoBuildPlugin } from '../../build/build-types.js';
-export type AssetSource = 'content' | 'file' | 'node-module';
-export type AssetKind = 'script' | 'stylesheet';
-export type AssetPosition = 'head' | 'body';
-export interface BaseAsset {
-    kind: AssetKind;
-    source: AssetSource;
-    attributes?: Record<string, string>;
-    position?: AssetPosition;
-}
-export interface ScriptAsset extends BaseAsset {
-    kind: 'script';
-    inline?: boolean;
-    bundle?: boolean;
-    bundleOptions?: {
-        minify?: boolean;
-        external?: string[];
-        naming?: string;
-        plugins?: EcoBuildPlugin[];
-    };
-    /**
-     * Whether to exclude this asset from the HTML output.
-     * @default false
-     */
-    excludeFromHtml?: boolean;
-}
-export interface StylesheetAsset extends BaseAsset {
-    kind: 'stylesheet';
-    inline?: boolean;
-}
-export interface ContentScriptAsset extends ScriptAsset {
-    source: 'content';
-    content: string;
-    name?: string;
-}
-export interface InlineContentScriptAsset extends ContentScriptAsset {
-    inline: true;
-}
-export interface ContentStylesheetAsset extends StylesheetAsset {
-    source: 'content';
-    content: string;
-}
-export interface InlineContentStylesheetAsset extends ContentStylesheetAsset {
-    inline: true;
-}
-export interface FileScriptAsset extends ScriptAsset {
-    source: 'file';
-    filepath: string;
-    name?: string;
-}
-export interface InlineFileScriptAsset extends FileScriptAsset {
-    inline: true;
-}
-export interface FileStylesheetAsset extends StylesheetAsset {
-    source: 'file';
-    filepath: string;
-    name?: string;
-}
-export interface InlineFileStylesheetAsset extends FileStylesheetAsset {
-    inline: true;
-}
-export interface NodeModuleScriptAsset extends ScriptAsset {
-    kind: 'script';
-    source: 'node-module';
-    importPath: string;
-    name?: string;
-}
-export interface InlineNodeModuleScriptAsset extends NodeModuleScriptAsset {
-    inline: true;
-}
-export interface InlineNodeModuleScriptAsset extends NodeModuleScriptAsset {
-    inline: true;
-}
-export interface JsonScriptAsset extends ScriptAsset {
-    source: 'content';
-    content: string;
-}
-export type ProcessedAsset = {
-    filepath?: string;
-    srcUrl?: string;
-    content?: string;
-    kind: AssetKind;
-    position?: AssetPosition;
-    attributes?: Record<string, string>;
-    inline?: boolean;
-    excludeFromHtml?: boolean;
-};
-export type AssetDefinition = ContentScriptAsset | FileScriptAsset | NodeModuleScriptAsset | JsonScriptAsset | ContentStylesheetAsset | FileStylesheetAsset;

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

@@ -1,3 +0,0 @@
-export * from './asset.factory';
-export * from './asset-processing.service';
-export * from './assets.types';

package/src/services/asset-processing-service/index.js

@@ -1,3 +0,0 @@
-export * from "./asset.factory";
-export * from "./asset-processing.service";
-export * from "./assets.types";

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

@@ -1,22 +0,0 @@
-import type { IHmrManager } from '../../internal-types';
-import type { AssetDefinition, ProcessedAsset } from './assets.types';
-/**
- * Base interface for asset processors.
- * Processors transform asset definitions into processed assets.
- */
-export interface AssetProcessor<T extends AssetDefinition = AssetDefinition> {
-    process(asset: T): Promise<ProcessedAsset>;
-}
-/**
- * Interface for processors that support HMR (Hot Module Replacement).
- * These processors can receive an HMR manager to enable hot reloading capabilities.
- */
-export interface HmrAwareProcessor extends AssetProcessor {
-    setHmrManager(hmrManager: IHmrManager): void;
-}
-/**
- * Type guard to check if a processor supports HMR.
- * @param processor - The processor to check
- * @returns True if the processor implements HmrAwareProcessor
- */
-export declare function isHmrAware(processor: AssetProcessor): processor is HmrAwareProcessor;

package/src/services/asset-processing-service/processor.interface.js

@@ -1,6 +0,0 @@
-function isHmrAware(processor) {
-  return "setHmrManager" in processor && typeof processor.setHmrManager === "function";
-}
-export {
-  isHmrAware
-};

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

@@ -1,8 +0,0 @@
-import type { AssetKind, AssetSource } from './assets.types';
-import type { BaseProcessor } from './processors/base/base-processor';
-export declare class ProcessorRegistry {
-    private processors;
-    register(kind: AssetKind, variant: AssetSource, processor: BaseProcessor<any>): void;
-    getProcessor(kind: AssetKind, variant: AssetSource): BaseProcessor<any> | undefined;
-    getAllProcessors(): Map<`${AssetKind}-${AssetSource}`, BaseProcessor<any>>;
-}

package/src/services/asset-processing-service/processor.registry.js

@@ -1,15 +0,0 @@
-class ProcessorRegistry {
-  processors = /* @__PURE__ */ new Map();
-  register(kind, variant, processor) {
-    this.processors.set(`${kind}-${variant}`, processor);
-  }
-  getProcessor(kind, variant) {
-    return this.processors.get(`${kind}-${variant}`);
-  }
-  getAllProcessors() {
-    return this.processors;
-  }
-}
-export {
-  ProcessorRegistry
-};

package/src/services/asset-processing-service/processors/base/base-processor.d.ts

@@ -1,24 +0,0 @@
-import type { EcoPagesAppConfig } from '../../../../internal-types.js';
-import type { BaseAsset, ProcessedAsset } from '../../assets.types.js';
-export declare abstract class BaseProcessor<T extends BaseAsset> {
-    protected appConfig: EcoPagesAppConfig;
-    /**
-     * Cache for processed assets to avoid reprocessing the same asset multiple times.
-     * The cache key is a combination of the asset name and its hash.
-     * The cache value is the processed asset.
-     */
-    protected cache: Map<string, ProcessedAsset>;
-    constructor({ appConfig }: {
-        appConfig: EcoPagesAppConfig;
-    });
-    get isDevelopment(): boolean;
-    get isProduction(): boolean;
-    abstract process(dep: T): Promise<ProcessedAsset>;
-    protected getAssetsDir(): string;
-    protected writeCacheFile(key: string, path: ProcessedAsset): void;
-    protected getCacheFile(key: string): ProcessedAsset | undefined;
-    protected hasCacheFile(key: string): boolean;
-    protected generateHash(content: string): string;
-    protected buildCacheKey(identifier: string, contentHash: string, dep: T): string;
-    protected getOrProcess(cacheKey: string, processFn: () => ProcessedAsset | Promise<ProcessedAsset>): Promise<ProcessedAsset>;
-}

package/src/services/asset-processing-service/processors/base/base-processor.js

@@ -1,59 +0,0 @@
-import path from "node:path";
-import { RESOLVED_ASSETS_DIR } from "../../../../constants.js";
-import { rapidhash } from "../../../../utils/hash.js";
-import { isDevelopmentRuntime, isProductionRuntime } from "../../../../utils/runtime.js";
-class BaseProcessor {
-  appConfig;
-  /**
-   * Cache for processed assets to avoid reprocessing the same asset multiple times.
-   * The cache key is a combination of the asset name and its hash.
-   * The cache value is the processed asset.
-   */
-  cache = /* @__PURE__ */ new Map();
-  constructor({ appConfig }) {
-    this.appConfig = appConfig;
-  }
-  get isDevelopment() {
-    return isDevelopmentRuntime();
-  }
-  get isProduction() {
-    return isProductionRuntime();
-  }
-  getAssetsDir() {
-    return path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR);
-  }
-  writeCacheFile(key, path2) {
-    this.cache.set(key, path2);
-  }
-  getCacheFile(key) {
-    return this.cache.get(key);
-  }
-  hasCacheFile(key) {
-    return this.cache.has(key);
-  }
-  generateHash(content) {
-    return rapidhash(content).toString();
-  }
-  buildCacheKey(identifier, contentHash, dep) {
-    const attrsHash = dep.attributes ? this.generateHash(JSON.stringify(dep.attributes)) : "";
-    const position = dep.position ?? "";
-    return `${identifier}:${contentHash}:${position}:${attrsHash}`;
-  }
-  getOrProcess(cacheKey, processFn) {
-    if (this.hasCacheFile(cacheKey)) {
-      return Promise.resolve(this.getCacheFile(cacheKey));
-    }
-    const result = processFn();
-    if (result instanceof Promise) {
-      return result.then((asset) => {
-        this.writeCacheFile(cacheKey, asset);
-        return asset;
-      });
-    }
-    this.writeCacheFile(cacheKey, result);
-    return Promise.resolve(result);
-  }
-}
-export {
-  BaseProcessor
-};

package/src/services/asset-processing-service/processors/base/base-script-processor.d.ts

@@ -1,16 +0,0 @@
-import type { EcoPagesAppConfig } from '../../../../internal-types';
-import type { EcoBuildPlugin } from '../../../../build/build-types.js';
-import type { ScriptAsset } from '../../assets.types';
-import { BaseProcessor } from './base-processor';
-export declare abstract class BaseScriptProcessor<T extends ScriptAsset> extends BaseProcessor<T> {
-    constructor({ appConfig }: {
-        appConfig: EcoPagesAppConfig;
-    });
-    protected shouldBundle(dep: T): boolean;
-    protected getBundlerOptions(dep: T): Record<string, any>;
-    protected collectBuildPlugins(): EcoBuildPlugin[];
-    protected bundleScript({ entrypoint, outdir, plugins: additionalPlugins, ...rest }: {
-        entrypoint: string;
-        outdir: string;
-    } & ScriptAsset['bundleOptions']): Promise<string>;
-}