@ecopages/core 0.2.0-alpha.54 → 0.2.0-alpha.55

package/src/plugins/processor.ts

@@ -1,257 +0,0 @@
-import path from 'node:path';
-import { fileSystem } from '@ecopages/file-system';
-import type { EcoBuildPlugin } from '../build/build-types.ts';
-import type { EcoPagesAppConfig, IClientBridge } from '../types/internal-types.ts';
-import type { AssetDefinition } from '../services/assets/asset-processing-service/assets.types.ts';
-import { DEFAULT_ECOPAGES_WORK_DIR } from '../config/constants.ts';
-import { GENERATED_BASE_PATHS } from '../config/constants.ts';
-import { deepMerge } from '../utils/deep-merge.ts';
-import type { RuntimeCapabilityDeclaration } from './runtime-capability.ts';
-
-export type { RuntimeCapabilityDeclaration, RuntimeCapabilityTag } from './runtime-capability.ts';
-export type {
-	EcoBuildLoader,
-	EcoBuildOnLoadArgs,
-	EcoBuildOnLoadResult,
-	EcoBuildOnResolveArgs,
-	EcoBuildOnResolveResult,
-	EcoBuildPlugin,
-	EcoBuildPluginBuilder,
-} from '../build/build-types.ts';
-
-export const PROCESSOR_ERRORS = {
-	CACHE_DIRECTORY_NOT_SET: 'Cache directory not set in context',
-} as const;
-
-export function mergeProcessorOptions<TDefaults, TOverrides>(
-	defaults: TDefaults,
-	overrides: TOverrides,
-): TDefaults & TOverrides {
-	return deepMerge(defaults, overrides);
-}
-
-function resolveGeneratedPath(
-	type: keyof typeof GENERATED_BASE_PATHS,
-	options: { root: string; module: string; subPath?: string },
-): string {
-	const { root, module, subPath } = options;
-	const parts = [root, GENERATED_BASE_PATHS[type], module, subPath].filter(Boolean);
-	return path.join(...(parts as string[]));
-}
-
-export interface ProcessorWatchContext {
-	path: string;
-	bridge: IClientBridge;
-}
-
-export interface ProcessorWatchConfig {
-	paths: string[];
-	extensions?: string[];
-	onCreate?: (ctx: ProcessorWatchContext) => Promise<void>;
-	onChange?: (ctx: ProcessorWatchContext) => Promise<void>;
-	onDelete?: (ctx: ProcessorWatchContext) => Promise<void>;
-	onError?: (error: Error) => void;
-}
-
-export type ProcessorAssetKind = 'script' | 'stylesheet' | 'image';
-export type ProcessorExtensionPattern = string;
-
-export interface ProcessorAssetCapability {
-	kind: ProcessorAssetKind;
-	/**
-	 * Supported patterns:
-	 * - `*` (all extensions)
-	 * - `.css` or `css`
-	 * - `*.css`
-	 * - `*.{css,scss,sass}`
-	 *
-	 * Pattern matching is case-insensitive and trims surrounding spaces,
-	 * including grouped values (e.g. `*.{ CSS, ScSs }`).
-	 */
-	extensions?: ProcessorExtensionPattern[];
-}
-
-export interface ProcessorConfig<TOptions = Record<string, unknown>> {
-	name: string;
-	description?: string;
-	options?: TOptions;
-	watch?: ProcessorWatchConfig;
-	capabilities?: ProcessorAssetCapability[];
-	runtimeCapability?: RuntimeCapabilityDeclaration;
-}
-export interface ProcessorContext {
-	config: EcoPagesAppConfig;
-	rootDir: string;
-	srcDir: string;
-	distDir: string;
-	cache?: string;
-}
-
-/**
- * Interface for processor build plugins
- * This is used to pass plugins to the build process directly from the processor
- * For instance it can become very handy when dealing with virtual modules that needs to be recognized by the bundler
- * i.e. @ecopages/image-processor
- */
-export abstract class Processor<TOptions = Record<string, unknown>> {
-	readonly name: string;
-	protected dependencies: AssetDefinition[] = [];
-	protected context?: ProcessorContext;
-	protected options?: TOptions;
-	protected watchConfig?: ProcessorWatchConfig;
-	protected capabilities: ProcessorAssetCapability[] = [];
-	readonly runtimeCapability?: RuntimeCapabilityDeclaration;
-
-	/** Plugins that are only used during the build process */
-	abstract buildPlugins?: EcoBuildPlugin[];
-
-	/** Plugins that are used during runtime for file processing */
-	abstract plugins?: EcoBuildPlugin[];
-
-	constructor(config: ProcessorConfig<TOptions>) {
-		this.name = config.name;
-		this.options = config.options;
-		this.watchConfig = config.watch;
-		this.capabilities = config.capabilities ?? [];
-		this.runtimeCapability = config.runtimeCapability;
-	}
-
-	setContext(appConfig: EcoPagesAppConfig): void {
-		const workDir =
-			appConfig.absolutePaths.workDir ??
-			path.join(appConfig.rootDir, appConfig.workDir ?? DEFAULT_ECOPAGES_WORK_DIR);
-		const cachePath = resolveGeneratedPath('cache', {
-			root: workDir,
-			module: this.name,
-		});
-
-		fileSystem.ensureDir(cachePath);
-
-		this.context = {
-			config: appConfig,
-			rootDir: appConfig.rootDir,
-			srcDir: appConfig.absolutePaths.srcDir,
-			distDir: appConfig.absolutePaths.distDir,
-			cache: cachePath,
-		};
-	}
-
-	/**
-	 * Prepares build-facing processor contributions before config finalization.
-	 *
-	 * @remarks
-	 * Override this when a processor must compute runtime/build plugins or other
-	 * manifest-owned state before startup. Runtime-only work such as cache
-	 * warming or watcher registration should stay in `setup()`.
-	 */
-	async prepareBuildContributions(): Promise<void> {}
-
-	abstract setup(): Promise<void>;
-	abstract teardown(): Promise<void>;
-	abstract process(input: unknown, filePath?: string): Promise<unknown>;
-
-	protected getCachePath(key: string): string {
-		return `${this.context?.cache}/${key}`;
-	}
-
-	protected async readCache<T>(key: string): Promise<T | null> {
-		const cachePath = this.getCachePath(key);
-		try {
-			const data = await fileSystem.readFile(cachePath);
-			return JSON.parse(data) as T;
-		} catch {
-			return null;
-		}
-	}
-
-	protected async writeCache<T>(key: string, data: T): Promise<void> {
-		if (!this.context?.cache) {
-			throw new Error(PROCESSOR_ERRORS.CACHE_DIRECTORY_NOT_SET);
-		}
-
-		const cachePath = this.getCachePath(key);
-		fileSystem.write(cachePath, JSON.stringify(data, null, 2));
-	}
-
-	getWatchConfig(): ProcessorWatchConfig | undefined {
-		return this.watchConfig;
-	}
-
-	getDependencies(): AssetDefinition[] {
-		return this.dependencies;
-	}
-
-	getName(): string {
-		return this.name;
-	}
-
-	getAssetCapabilities(): ProcessorAssetCapability[] {
-		return this.capabilities;
-	}
-
-	matchesFileFilter(_filepath: string): boolean {
-		return true;
-	}
-
-	canProcessAsset(kind: ProcessorAssetKind, filepath?: string): boolean {
-		const capabilities = this.getAssetCapabilities();
-		if (capabilities.length === 0) {
-			return false;
-		}
-
-		const matchingKind = capabilities.filter((capability) => capability.kind === kind);
-		if (matchingKind.length === 0) {
-			return false;
-		}
-
-		if (!filepath) {
-			return true;
-		}
-
-		return matchingKind.some((capability) => this.matchesCapabilityExtensions(filepath, capability.extensions));
-	}
-
-	private matchesCapabilityExtensions(filepath: string, extensions?: ProcessorExtensionPattern[]): boolean {
-		if (!extensions || extensions.length === 0) {
-			return true;
-		}
-
-		const normalizedExt = path.extname(filepath).toLowerCase();
-
-		return extensions.some((rawPattern) => {
-			const pattern = this.normalizeExtensionPattern(rawPattern);
-			if (!pattern) {
-				return false;
-			}
-
-			if (pattern === '*') {
-				return true;
-			}
-
-			const groupedMatch = pattern.match(/^\*\.\{(.+)\}$/);
-			if (groupedMatch) {
-				const groupItems = groupedMatch[1]
-					.split(',')
-					.map((item) => this.normalizeExtensionPattern(item))
-					.filter(Boolean);
-
-				return groupItems.some((item) => normalizedExt === item || normalizedExt === `.${item}`);
-			}
-
-			if (pattern.startsWith('*')) {
-				const suffix = pattern.slice(1);
-				return normalizedExt.endsWith(suffix);
-			}
-
-			if (pattern.startsWith('.')) {
-				return normalizedExt === pattern;
-			}
-
-			return normalizedExt === `.${pattern}`;
-		});
-	}
-
-	private normalizeExtensionPattern(rawPattern: string): string {
-		return rawPattern.trim().toLowerCase();
-	}
-}

package/src/plugins/source-transform.test.ts

@@ -1,82 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { fileSystem } from '@ecopages/file-system';
-import {
-	applySourceTransform,
-	createVitePluginsFromAppSourceTransforms,
-	createEcoBuildPluginFromSourceTransform,
-	getAppSourceTransforms,
-	createVitePluginFromSourceTransform,
-	normalizeTransformId,
-	type EcoSourceTransform,
-} from './source-transform.ts';
-import type { EcoPagesAppConfig } from '../types/internal-types.ts';
-
-describe('source-transform', () => {
-	const transform: EcoSourceTransform = {
-		name: 'test-transform',
-		filter: /main\.tsx$/,
-		transform(code) {
-			return {
-				code: `/* injected */\n${code}`,
-			};
-		},
-	};
-
-	it('normalizes ids by stripping query and hash suffixes', () => {
-		expect(normalizeTransformId('/src/main.tsx?import')).toBe('/src/main.tsx');
-		expect(normalizeTransformId('/src/main.tsx#hash')).toBe('/src/main.tsx');
-	});
-
-	it('applies transforms against normalized ids', () => {
-		const result = applySourceTransform(transform, 'export const value = 1;', '/src/main.tsx?import');
-
-		expect(result).toEqual({
-			code: '/* injected */\nexport const value = 1;',
-		});
-	});
-
-	it('creates a Vite-compatible transform plugin', () => {
-		const vitePlugin = createVitePluginFromSourceTransform(transform);
-		const result = vitePlugin.transform('export const value = 1;', '/src/main.tsx?import');
-
-		expect(vitePlugin.name).toBe('test-transform');
-		expect(result).toEqual({
-			code: '/* injected */\nexport const value = 1;',
-		});
-	});
-
-	it('creates an Ecopages build plugin wrapper', async () => {
-		const buildPlugin = createEcoBuildPluginFromSourceTransform(transform);
-		let onLoadCallback: ((args: { path: string }) => unknown) | undefined;
-
-		buildPlugin.setup({
-			onLoad(_options: unknown, callback: unknown) {
-				onLoadCallback = callback as typeof onLoadCallback;
-			},
-		} as never);
-
-		const readSpy = vi.spyOn(fileSystem, 'readFileSync').mockReturnValue('export const value = 1;');
-
-		try {
-			const result = await onLoadCallback?.({ path: '/src/main.tsx?import' });
-
-			expect(result).toEqual({
-				contents: '/* injected */\nexport const value = 1;',
-				loader: 'tsx',
-				resolveDir: '/src',
-			});
-		} finally {
-			readSpy.mockRestore();
-		}
-	});
-
-	it('collects app-owned source transforms and adapts them to Vite plugins', () => {
-		const appConfig = {
-			sourceTransforms: new Map([[transform.name, transform]]),
-		} as EcoPagesAppConfig;
-
-		expect(getAppSourceTransforms(appConfig)).toEqual([transform]);
-		expect(createVitePluginsFromAppSourceTransforms(appConfig)).toHaveLength(1);
-		expect(createVitePluginsFromAppSourceTransforms(appConfig)[0].name).toBe('test-transform');
-	});
-});

package/src/plugins/source-transform.ts

@@ -1,123 +0,0 @@
-import path from 'node:path';
-import { fileSystem } from '@ecopages/file-system';
-import type { EcoBuildPlugin } from '../build/build-types.ts';
-import type { EcoPagesAppConfig } from '../types/internal-types.ts';
-
-export interface EcoSourceTransformResult {
-	code: string;
-	map?: unknown;
-}
-
-export interface EcoSourceTransform {
-	name: string;
-	filter: RegExp;
-	enforce?: 'pre' | 'post';
-	transform(code: string, id: string): EcoSourceTransformResult | string | undefined;
-}
-
-export interface EcoViteCompatiblePlugin {
-	name: string;
-	enforce?: 'pre' | 'post';
-	transform(code: string, id: string): EcoSourceTransformResult | string | undefined;
-}
-
-/**
- * Normalizes bundler module ids so one transform can serve Ecopages loaders,
- * Vite, and future bundler adapters.
- */
-export function normalizeTransformId(id: string): string {
-	const queryIndex = id.indexOf('?');
-	const hashIndex = id.indexOf('#');
-	const endIndex = [queryIndex, hashIndex].filter((index) => index >= 0).sort((left, right) => left - right)[0];
-
-	return endIndex === undefined ? id : id.slice(0, endIndex);
-}
-
-/**
- * Applies one source transform if the normalized id matches its filter.
- */
-export function applySourceTransform(
-	transform: EcoSourceTransform,
-	code: string,
-	id: string,
-): EcoSourceTransformResult | string | undefined {
-	const normalizedId = normalizeTransformId(id);
-
-	if (!transform.filter.test(normalizedId)) {
-		return undefined;
-	}
-
-	return transform.transform(code, normalizedId);
-}
-
-function inferLoaderFromPath(filePath: string): 'ts' | 'tsx' | 'js' | 'jsx' {
-	const extension = path.extname(filePath).toLowerCase();
-
-	switch (extension) {
-		case '.ts':
-			return 'ts';
-		case '.tsx':
-			return 'tsx';
-		case '.jsx':
-			return 'jsx';
-		default:
-			return 'js';
-	}
-}
-
-/**
- * Adapts a source transform into the existing Ecopages build-plugin contract.
- */
-export function createEcoBuildPluginFromSourceTransform(transform: EcoSourceTransform): EcoBuildPlugin {
-	return {
-		name: transform.name,
-		setup(build) {
-			build.onLoad({ filter: transform.filter }, (args) => {
-				const filePath = normalizeTransformId(args.path);
-				const code = fileSystem.readFileSync(filePath);
-				const result = applySourceTransform(transform, code, filePath);
-
-				if (!result) {
-					return undefined;
-				}
-
-				return {
-					contents: typeof result === 'string' ? result : result.code,
-					loader: inferLoaderFromPath(filePath),
-					resolveDir: path.dirname(filePath),
-				};
-			});
-		},
-	};
-}
-
-/**
- * Adapts a source transform into a Vite-compatible plugin object.
- *
- * @remarks
- * This intentionally returns a plain object shape so core does not need a hard
- * dependency on `vite` just to author transform primitives.
- */
-export function createVitePluginFromSourceTransform(transform: EcoSourceTransform): EcoViteCompatiblePlugin {
-	return {
-		name: transform.name,
-		enforce: transform.enforce,
-		transform(code, id) {
-			return applySourceTransform(transform, code, id);
-		},
-	};
-}
-
-/**
- * Returns the app-owned source transforms in stable registration order.
- */
-export function getAppSourceTransforms(appConfig: EcoPagesAppConfig): EcoSourceTransform[] {
-	return Array.from(appConfig.sourceTransforms.values());
-}
-
-/**
- * Adapts the app-owned source transforms into Vite-compatible plugin objects.
- */
-export function createVitePluginsFromAppSourceTransforms(appConfig: EcoPagesAppConfig): EcoViteCompatiblePlugin[] {
-	return getAppSourceTransforms(appConfig).map((transform) => createVitePluginFromSourceTransform(transform));
-}