@ecopages/core 0.2.0-alpha.8 → 0.2.1

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

@@ -1,113 +0,0 @@
-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?: {
-		define?: Record<string, string>;
-		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/assets/asset-processing-service/browser-runtime-asset.factory.ts

@@ -1,95 +0,0 @@
-import type { EcoBuildPlugin } from '../../../build/build-types.ts';
-import { AssetFactory } from './asset.factory.ts';
-import type { AssetDefinition } from './assets.types.ts';
-import {
-	createBrowserRuntimeEntryModule,
-	type BrowserRuntimeEntryModuleConfig,
-} from './browser-runtime-entry.factory.ts';
-
-export const BROWSER_RUNTIME_SCRIPT_ATTRIBUTES = {
-	type: 'module',
-	defer: '',
-} as const;
-
-/**
- * Builds the public vendor URL used for generated browser runtime assets.
- */
-export function buildBrowserRuntimeAssetUrl(fileName: string): string {
-	return `/${AssetFactory.RESOLVED_ASSETS_VENDORS_DIR}/${fileName}`;
-}
-
-/**
- * Declares a browser runtime script asset backed by one importable module.
- *
- * @remarks
- * Runtime assets are emitted as excluded head scripts because integrations often
- * need the bundler output and specifier registration without injecting the raw
- * asset directly into HTML during dependency resolution.
- */
-export function createBrowserRuntimeScriptAsset(options: {
-	importPath: string;
-	name: string;
-	fileName: string;
-	bundleOptions?: {
-		define?: Record<string, string>;
-		minify?: boolean;
-		external?: string[];
-		naming?: string;
-		plugins?: EcoBuildPlugin[];
-	};
-	attributes?: Record<string, string>;
-}): AssetDefinition {
-	return AssetFactory.createNodeModuleScript({
-		position: 'head',
-		importPath: options.importPath,
-		name: options.name,
-		excludeFromHtml: true,
-		bundleOptions: {
-			naming: options.fileName,
-			...options.bundleOptions,
-		},
-		attributes: {
-			...BROWSER_RUNTIME_SCRIPT_ATTRIBUTES,
-			...(options.attributes ?? {}),
-		},
-	});
-}
-
-/**
- * Creates a browser runtime asset from a generated re-export entry module.
- *
- * @remarks
- * This is the shared "module list -> generated entry file -> runtime asset"
- * path used by integrations that need browser-side runtime bundles without
- * owning bespoke entry-file generation logic.
- */
-export function createBrowserRuntimeModuleAsset(options: {
-	modules: BrowserRuntimeEntryModuleConfig[];
-	name: string;
-	fileName: string;
-	cacheDirName?: string;
-	rootDir?: string;
-	bundleOptions?: {
-		define?: Record<string, string>;
-		minify?: boolean;
-		external?: string[];
-		naming?: string;
-		plugins?: EcoBuildPlugin[];
-	};
-	attributes?: Record<string, string>;
-}): AssetDefinition {
-	const importPath = createBrowserRuntimeEntryModule({
-		modules: options.modules,
-		fileName: `${options.name}-entry.mjs`,
-		rootDir: options.rootDir,
-		cacheDirName: options.cacheDirName,
-	});
-
-	return createBrowserRuntimeScriptAsset({
-		importPath,
-		name: options.name,
-		fileName: options.fileName,
-		bundleOptions: options.bundleOptions,
-		attributes: options.attributes,
-	});
-}

package/src/services/assets/asset-processing-service/browser-runtime-entry.factory.ts

@@ -1,78 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { createRequire } from 'node:module';
-
-export type BrowserRuntimeEntryModuleConfig = {
-	specifier: string;
-	defaultExport?: boolean;
-};
-
-/**
- * Creates a generated ESM entry module that re-exports runtime modules through
- * one stable file.
- *
- * @remarks
- * Integrations use this helper when they need a browser runtime asset composed
- * from multiple bare specifiers but do not want to own temporary file assembly
- * logic themselves. The generated file lives under a cache directory inside the
- * consuming app root so repeated runs can reuse the same location.
- */
-export function createBrowserRuntimeEntryModule(options: {
-	modules: BrowserRuntimeEntryModuleConfig[];
-	fileName: string;
-	rootDir?: string;
-	cacheDirName?: string;
-}): string {
-	const rootDir = options.rootDir ?? process.cwd();
-	const artifactsDir = path.join(
-		rootDir,
-		'node_modules',
-		'.cache',
-		options.cacheDirName ?? 'ecopages-browser-runtime',
-	);
-	fs.mkdirSync(artifactsDir, { recursive: true });
-
-	const requireFromRoot = createRequire(path.join(rootDir, 'package.json'));
-	const seenExports = new Set<string>();
-	const statements: string[] = [];
-
-	for (const module of options.modules) {
-		if (module.defaultExport) {
-			statements.push(`import __ecopages_default_export__ from '${module.specifier}';`);
-			statements.push('export default __ecopages_default_export__;');
-		}
-
-		const exportNames = getModuleExportNames(module.specifier, requireFromRoot).filter(
-			(name) => !seenExports.has(name),
-		);
-
-		if (exportNames.length > 0) {
-			statements.push(`export { ${exportNames.join(', ')} } from '${module.specifier}';`);
-			for (const exportName of exportNames) {
-				seenExports.add(exportName);
-			}
-		}
-	}
-
-	const filePath = path.join(artifactsDir, options.fileName);
-	fs.writeFileSync(filePath, statements.join('\n'), 'utf-8');
-	return filePath;
-}
-
-/**
- * Reads the named runtime exports that should be re-exported from a generated
- * runtime entry module.
- *
- * @remarks
- * Default exports are handled separately because generated runtime entry files
- * need to emit a synthetic default binding only when the caller explicitly asks
- * for it.
- */
-function getModuleExportNames(specifier: string, requireFromRoot: ReturnType<typeof createRequire>): string[] {
-	const moduleExports = requireFromRoot(specifier);
-
-	return Object.keys(moduleExports)
-		.filter((name) => name !== '__esModule' && name !== 'default')
-		.filter((name) => /^[$A-Z_a-z][$\w]*$/.test(name))
-		.sort();
-}

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

@@ -1,5 +0,0 @@
-export * from './asset.factory';
-export * from './asset-processing.service';
-export * from './assets.types';
-export * from './browser-runtime-asset.factory';
-export * from './browser-runtime-entry.factory';

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

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

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

@@ -1,18 +0,0 @@
-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/assets/asset-processing-service/processors/base/base-processor.ts

@@ -1,82 +0,0 @@
-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';
-import { fileSystem } from '@ecopages/file-system';
-
-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)) {
-			const cached = this.getCacheFile(cacheKey) as ProcessedAsset;
-			if (!cached.filepath || fileSystem.exists(cached.filepath)) {
-				return Promise.resolve(cached);
-			}
-
-			this.cache.delete(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);
-	}
-}

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

@@ -1,95 +0,0 @@
-import { appLogger } from '../../../../../global/app-logger';
-import type { EcoPagesAppConfig } from '../../../../../internal-types';
-import { getAppBrowserBuildPlugins } from '../../../../../build/build-adapter.ts';
-import type { EcoBuildPlugin } from '../../../../../build/build-types.ts';
-import { fileSystem } from '@ecopages/file-system';
-import path from 'node:path';
-import type { ScriptAsset } from '../../assets.types';
-import { BaseProcessor } from './base-processor';
-import { BrowserBundleService } from '../../../browser-bundle.service.ts';
-
-export abstract class BaseScriptProcessor<T extends ScriptAsset> extends BaseProcessor<T> {
-	private readonly browserBundleService: BrowserBundleService;
-
-	constructor({ appConfig }: { appConfig: EcoPagesAppConfig }) {
-		super({ appConfig });
-		this.browserBundleService = new BrowserBundleService(appConfig);
-	}
-
-	protected shouldBundle(dep: T): boolean {
-		return dep.bundle !== false;
-	}
-
-	protected getBundlerOptions(dep: T): Record<string, any> {
-		return dep.bundleOptions || {};
-	}
-
-	protected collectBuildPlugins(): EcoBuildPlugin[] {
-		return getAppBrowserBuildPlugins(this.appConfig);
-	}
-
-	protected async bundleScript({
-		entrypoint,
-		outdir,
-		plugins: additionalPlugins,
-		...rest
-	}: {
-		entrypoint: string;
-		outdir: string;
-	} & ScriptAsset['bundleOptions']): Promise<string> {
-		const buildPlugins = this.collectBuildPlugins();
-		const allPlugins = additionalPlugins ? [...additionalPlugins, ...buildPlugins] : buildPlugins;
-
-		const buildResult = await this.browserBundleService.bundle({
-			profile: 'browser-script',
-			entrypoints: [entrypoint],
-			outdir,
-			root: this.appConfig.rootDir,
-			splitting: true,
-			naming: '[name]-[hash].[ext]',
-			plugins: allPlugins,
-			...rest,
-		});
-
-		if (!buildResult.success) {
-			for (const log of buildResult.logs) {
-				appLogger.debug(log.message, log);
-			}
-		}
-
-		const entryBaseName = path.parse(entrypoint).name;
-		const entryOutput = buildResult.outputs
-			.map((output) => output.path)
-			.find((outputPath) => path.basename(outputPath) === `${entryBaseName}.js`);
-
-		if (entryOutput) {
-			return entryOutput;
-		}
-
-		const nonVendorOutput = buildResult.outputs
-			.map((output) => output.path)
-			.find((outputPath) => !path.basename(outputPath).startsWith('vendors'));
-
-		if (nonVendorOutput) {
-			return nonVendorOutput;
-		}
-
-		const primaryOutput = buildResult.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 = buildResult.logs.map((log) => log.message).join(' | ');
-		throw new Error(`No build output generated for ${entrypoint}${logMessage ? `: ${logMessage}` : ''}`);
-	}
-}

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

@@ -1,5 +0,0 @@
-export * from './script/content-script.processor';
-export * from './script/file-script.processor';
-export * from './script/node-module-script.processor';
-export * from './stylesheet/content-stylesheet.processor';
-export * from './stylesheet/file-stylesheet.processor';

package/src/services/assets/asset-processing-service/processors/script/content-script.processor.ts

@@ -1,66 +0,0 @@
-import path from 'node:path';
-import { fileSystem } from '@ecopages/file-system';
-import type { ContentScriptAsset, ProcessedAsset } from '../../assets.types';
-import { BaseScriptProcessor } from '../base/base-script-processor';
-
-export class ContentScriptProcessor extends BaseScriptProcessor<ContentScriptAsset> {
-	async process(dep: ContentScriptAsset): Promise<ProcessedAsset> {
-		const hash = this.generateHash(dep.content);
-		const filename = dep.name ? `${dep.name}.js` : `script-${hash}.js`;
-		const shouldBundle = this.shouldBundle(dep);
-
-		const filepath = path.join(this.getAssetsDir(), 'scripts', filename);
-
-		if (!shouldBundle) {
-			if (!dep.inline) fileSystem.write(filepath, dep.content);
-			const unbundledProcessedAsset: ProcessedAsset = {
-				filepath,
-				content: dep.inline ? dep.content : undefined,
-				kind: 'script',
-				position: dep.position,
-				attributes: dep.attributes,
-				inline: dep.inline,
-				excludeFromHtml: dep.excludeFromHtml,
-			};
-
-			this.writeCacheFile(filename, unbundledProcessedAsset);
-			return unbundledProcessedAsset;
-		}
-
-		if (dep.content) {
-			const tempDir = this.appConfig.absolutePaths.distDir;
-			fileSystem.ensureDir(tempDir);
-			const tempFileName = path.join(
-				tempDir,
-				`${path.parse(filename).name}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp.js`,
-			);
-			fileSystem.write(tempFileName, dep.content);
-
-			const bundledFilePath = await this.bundleScript({
-				entrypoint: tempFileName,
-				outdir: this.getAssetsDir(),
-				minify: this.isProduction,
-				naming: `${path.parse(filename).name}-[hash].[ext]`,
-				...this.getBundlerOptions(dep),
-			});
-
-			const processedAsset: ProcessedAsset = {
-				filepath: bundledFilePath,
-				content: dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : undefined,
-				kind: 'script',
-				position: dep.position,
-				attributes: dep.attributes,
-				inline: dep.inline,
-				excludeFromHtml: dep.excludeFromHtml,
-			};
-
-			fileSystem.remove(tempFileName);
-
-			this.writeCacheFile(filename, processedAsset);
-
-			return processedAsset;
-		}
-
-		throw new Error('No content found for script asset');
-	}
-}

package/src/services/assets/asset-processing-service/processors/script/file-script.processor.ts

@@ -1,88 +0,0 @@
-import path from 'node:path';
-import { RESOLVED_ASSETS_DIR } from '../../../../../constants';
-import { fileSystem } from '@ecopages/file-system';
-import type { IHmrManager } from '../../../../../internal-types';
-import type { FileScriptAsset, ProcessedAsset } from '../../assets.types';
-import { BaseScriptProcessor } from '../base/base-script-processor';
-
-export class FileScriptProcessor extends BaseScriptProcessor<FileScriptAsset> {
-	private hmrManager?: IHmrManager;
-
-	setHmrManager(hmrManager: IHmrManager) {
-		this.hmrManager = hmrManager;
-	}
-
-	async process(dep: FileScriptAsset): Promise<ProcessedAsset> {
-		/**
-		 * If HMR Manager is active, delegate build/watch to it.
-		 */
-		if (this.hmrManager?.isEnabled() && !dep.inline) {
-			const outputUrl = await this.hmrManager.registerScriptEntrypoint(dep.filepath);
-			return {
-				filepath: dep.filepath,
-				srcUrl: outputUrl,
-				kind: 'script',
-				position: dep.position,
-				attributes: dep.attributes,
-				inline: false,
-				excludeFromHtml: dep.excludeFromHtml,
-			};
-		}
-
-		const content = fileSystem.readFileSync(dep.filepath);
-		const shouldBundle = this.shouldBundle(dep);
-		const configHash = this.generateHash(
-			JSON.stringify({
-				bundle: shouldBundle,
-				minify: shouldBundle && this.isProduction,
-				opts: dep.bundleOptions,
-			}),
-		);
-		const cachekey = `${this.buildCacheKey(dep.filepath, this.generateHash(content), dep)}:${configHash}`;
-
-		return this.getOrProcess(cachekey, async () => {
-			if (!shouldBundle) {
-				const outFilepath = path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath);
-				let filepath: string | undefined;
-
-				if (!dep.inline) {
-					filepath = path.join(this.getAssetsDir(), outFilepath);
-					fileSystem.copyFile(dep.filepath, filepath);
-				}
-
-				return {
-					filepath,
-					content,
-					kind: 'script',
-					position: dep.position,
-					attributes: dep.attributes,
-					inline: dep.inline,
-					excludeFromHtml: dep.excludeFromHtml,
-				};
-			}
-
-			const relativeFilepath = path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath);
-			const outdirPath = path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR, relativeFilepath);
-			const outdirDirname = path.dirname(outdirPath);
-			const bundlerOptions = this.getBundlerOptions(dep);
-
-			const bundledFilePath = await this.bundleScript({
-				entrypoint: dep.filepath,
-				outdir: outdirDirname,
-				minify: this.isProduction,
-				...bundlerOptions,
-				plugins: bundlerOptions.plugins,
-			});
-
-			return {
-				filepath: bundledFilePath,
-				content: dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : undefined,
-				kind: 'script',
-				position: dep.position,
-				attributes: dep.attributes,
-				inline: dep.inline,
-				excludeFromHtml: dep.excludeFromHtml,
-			};
-		});
-	}
-}