@ecopages/core 0.2.0-alpha.1

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

@@ -0,0 +1,105 @@
+import { RESOLVED_ASSETS_DIR, RESOLVED_ASSETS_VENDORS_DIR } from '../../constants';
+import { deepMerge } from '../../utils/deep-merge';
+import type {
+	ContentScriptAsset,
+	ContentStylesheetAsset,
+	FileScriptAsset,
+	FileStylesheetAsset,
+	InlineContentScriptAsset,
+	InlineContentStylesheetAsset,
+	InlineFileScriptAsset,
+	JsonScriptAsset,
+	NodeModuleScriptAsset,
+} from './assets.types';
+
+type CreateAssetOptions<T> = Omit<T, 'kind' | 'source' | 'inline'>;
+
+export class AssetFactory {
+	static readonly RESOLVED_ASSETS_DIR = RESOLVED_ASSETS_DIR;
+	static readonly RESOLVED_ASSETS_VENDORS_DIR = RESOLVED_ASSETS_VENDORS_DIR;
+
+	static createContentScript(options: CreateAssetOptions<ContentScriptAsset>): ContentScriptAsset {
+		return {
+			kind: 'script',
+			source: 'content',
+			position: options.position || 'body',
+			...options,
+		};
+	}
+
+	static createInlineContentScript(options: CreateAssetOptions<InlineContentScriptAsset>): InlineContentScriptAsset {
+		return {
+			...AssetFactory.createContentScript(options),
+			inline: true,
+		};
+	}
+
+	static createFileScript(options: CreateAssetOptions<FileScriptAsset>): FileScriptAsset {
+		return {
+			kind: 'script',
+			source: 'file',
+			position: options.position || 'body',
+			...options,
+		};
+	}
+
+	static createInlineFileScript(options: CreateAssetOptions<InlineFileScriptAsset>): InlineFileScriptAsset {
+		return {
+			...AssetFactory.createFileScript(options),
+			inline: true,
+		};
+	}
+
+	static createNodeModuleScript(options: CreateAssetOptions<NodeModuleScriptAsset>): NodeModuleScriptAsset {
+		return {
+			kind: 'script',
+			source: 'node-module',
+			position: options.position || 'body',
+			...options,
+		};
+	}
+
+	static createInlineNodeModuleScript(options: CreateAssetOptions<NodeModuleScriptAsset>): NodeModuleScriptAsset {
+		return {
+			...AssetFactory.createNodeModuleScript(options),
+			inline: true,
+		};
+	}
+
+	static createJsonScript(options: CreateAssetOptions<JsonScriptAsset>): JsonScriptAsset {
+		return {
+			kind: 'script',
+			source: 'content',
+			attributes: deepMerge(options.attributes, { type: 'application/json' }),
+			position: options.position || 'body',
+			...options,
+		};
+	}
+
+	static createContentStylesheet(options: CreateAssetOptions<ContentStylesheetAsset>): ContentStylesheetAsset {
+		return {
+			kind: 'stylesheet',
+			source: 'content',
+			position: 'head',
+			...options,
+		};
+	}
+
+	static createInlineContentStylesheet(
+		options: CreateAssetOptions<InlineContentStylesheetAsset>,
+	): InlineContentStylesheetAsset {
+		return {
+			...AssetFactory.createContentStylesheet(options),
+			inline: true,
+		};
+	}
+
+	static createFileStylesheet(options: CreateAssetOptions<FileStylesheetAsset>): FileStylesheetAsset {
+		return {
+			kind: 'stylesheet',
+			source: 'file',
+			position: options.position || 'head',
+			...options,
+		};
+	}
+}

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

@@ -0,0 +1,88 @@
+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/assets.types.ts

@@ -0,0 +1,112 @@
+import type { EcoBuildPlugin } from '../../build/build-types.ts';
+
+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

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

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

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

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

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

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

@@ -0,0 +1,22 @@
+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

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

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

@@ -0,0 +1,27 @@
+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 function isHmrAware(processor: AssetProcessor): processor is HmrAwareProcessor {
+	return 'setHmrManager' in processor && typeof (processor as HmrAwareProcessor).setHmrManager === 'function';
+}

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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,15 @@
+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/processor.registry.ts

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

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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,59 @@
+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-processor.ts

@@ -0,0 +1,76 @@
+import path from 'node:path';
+import { RESOLVED_ASSETS_DIR } from '../../../../constants.ts';
+import type { EcoPagesAppConfig } from '../../../../internal-types.ts';
+import { rapidhash } from '../../../../utils/hash.ts';
+import { isDevelopmentRuntime, isProductionRuntime } from '../../../../utils/runtime.ts';
+import type { BaseAsset, ProcessedAsset } from '../../assets.types.ts';
+
+export 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> = new Map();
+
+	constructor({ appConfig }: { appConfig: EcoPagesAppConfig }) {
+		this.appConfig = appConfig;
+	}
+
+	get isDevelopment(): boolean {
+		return isDevelopmentRuntime();
+	}
+
+	get isProduction(): boolean {
+		return isProductionRuntime();
+	}
+
+	abstract process(dep: T): Promise<ProcessedAsset>;
+
+	protected getAssetsDir(): string {
+		return path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR);
+	}
+
+	protected writeCacheFile(key: string, path: ProcessedAsset): void {
+		this.cache.set(key, path);
+	}
+
+	protected getCacheFile(key: string): ProcessedAsset | undefined {
+		return this.cache.get(key);
+	}
+
+	protected hasCacheFile(key: string): boolean {
+		return this.cache.has(key);
+	}
+
+	protected generateHash(content: string): string {
+		return rapidhash(content).toString();
+	}
+
+	protected buildCacheKey(identifier: string, contentHash: string, dep: T): string {
+		const attrsHash = dep.attributes ? this.generateHash(JSON.stringify(dep.attributes)) : '';
+		const position = dep.position ?? '';
+		return `${identifier}:${contentHash}:${position}:${attrsHash}`;
+	}
+
+	protected getOrProcess(
+		cacheKey: string,
+		processFn: () => ProcessedAsset | Promise<ProcessedAsset>,
+	): Promise<ProcessedAsset> {
+		if (this.hasCacheFile(cacheKey)) {
+			return Promise.resolve(this.getCacheFile(cacheKey) as ProcessedAsset);
+		}
+
+		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);
+	}
+}

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

@@ -0,0 +1,16 @@
+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>;
+}

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

@@ -0,0 +1,80 @@
+import { appLogger } from "../../../../global/app-logger";
+import { defaultBuildAdapter } from "../../../../build/build-adapter.js";
+import { fileSystem } from "@ecopages/file-system";
+import path from "node:path";
+import { BaseProcessor } from "./base-processor";
+class BaseScriptProcessor extends BaseProcessor {
+  constructor({ appConfig }) {
+    super({ appConfig });
+  }
+  shouldBundle(dep) {
+    return dep.bundle !== false;
+  }
+  getBundlerOptions(dep) {
+    return dep.bundleOptions || {};
+  }
+  collectBuildPlugins() {
+    const plugins = [];
+    if (this.appConfig.processors?.size) {
+      for (const processor of this.appConfig.processors.values()) {
+        if (processor.buildPlugins) {
+          plugins.push(...processor.buildPlugins);
+        }
+      }
+    }
+    if (this.appConfig.loaders?.size) {
+      plugins.push(...this.appConfig.loaders.values());
+    }
+    return plugins;
+  }
+  async bundleScript({
+    entrypoint,
+    outdir,
+    plugins: additionalPlugins,
+    ...rest
+  }) {
+    const buildPlugins = this.collectBuildPlugins();
+    const allPlugins = additionalPlugins ? [...additionalPlugins, ...buildPlugins] : buildPlugins;
+    const build = await defaultBuildAdapter.build({
+      entrypoints: [entrypoint],
+      outdir,
+      root: this.appConfig.rootDir,
+      ...defaultBuildAdapter.getTranspileOptions("browser-script"),
+      splitting: true,
+      naming: "[name]-[hash].[ext]",
+      plugins: allPlugins,
+      ...rest
+    });
+    if (!build.success) {
+      for (const log of build.logs) {
+        appLogger.debug(log.message, log);
+      }
+    }
+    const entryBaseName = path.parse(entrypoint).name;
+    const entryOutput = build.outputs.map((output) => output.path).find((outputPath) => path.basename(outputPath) === `${entryBaseName}.js`);
+    if (entryOutput) {
+      return entryOutput;
+    }
+    const nonVendorOutput = build.outputs.map((output) => output.path).find((outputPath) => !path.basename(outputPath).startsWith("vendors"));
+    if (nonVendorOutput) {
+      return nonVendorOutput;
+    }
+    const primaryOutput = build.outputs[0]?.path;
+    if (primaryOutput) {
+      return primaryOutput;
+    }
+    const namedFallbackOutput = path.join(outdir, `${entryBaseName}.js`);
+    if (fileSystem.exists(namedFallbackOutput)) {
+      return namedFallbackOutput;
+    }
+    const fallbackOutput = path.join(outdir, "entry_0.js");
+    if (fileSystem.exists(fallbackOutput)) {
+      return fallbackOutput;
+    }
+    const logMessage = build.logs.map((log) => log.message).join(" | ");
+    throw new Error(`No build output generated for ${entrypoint}${logMessage ? `: ${logMessage}` : ""}`);
+  }
+}
+export {
+  BaseScriptProcessor
+};