@ecopages/core 0.2.0-alpha.8 → 0.2.1-beta.0

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,
-			};
-		});
-	}
-}

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

@@ -1,85 +0,0 @@
-import path from 'node:path';
-import { fileSystem } from '@ecopages/file-system';
-import { getAppBuildAdapter } from '../../../../../build/build-adapter.ts';
-import type { NodeModuleScriptAsset } from '../../assets.types';
-import { BaseScriptProcessor } from '../base/base-script-processor';
-
-export class NodeModuleScriptProcessor extends BaseScriptProcessor<NodeModuleScriptAsset> {
-	async process(dep: NodeModuleScriptAsset) {
-		const modulePath = this.resolveModulePath(dep.importPath, this.appConfig.rootDir);
-		const moduleName = path.basename(modulePath);
-		const filename = dep.name ?? `nm-${moduleName}`;
-		const configHash = this.generateHash(
-			JSON.stringify({ inline: dep.inline, minify: !dep.inline && this.isProduction, opts: dep.bundleOptions }),
-		);
-		const cachekey = `${this.buildCacheKey(filename, this.generateHash(modulePath), dep)}:${configHash}`;
-
-		return this.getOrProcess(cachekey, async () => {
-			if (dep.inline) {
-				const content = fileSystem.readFileAsBuffer(modulePath).toString();
-				return {
-					content,
-					kind: dep.kind,
-					position: dep.position,
-					attributes: dep.attributes,
-					inline: true,
-					excludeFromHtml: dep.excludeFromHtml,
-				};
-			}
-
-			const outdir = path.join(this.getAssetsDir(), 'vendors');
-			const bundlerOptions = this.getBundlerOptions(dep);
-
-			const filePath = await this.bundleScript({
-				entrypoint: modulePath,
-				outdir: outdir,
-				minify: this.isProduction,
-				naming: bundlerOptions.naming ?? (dep.name ? `${dep.name}-[hash].[ext]` : '[name]-[hash].[ext]'),
-				...bundlerOptions,
-			});
-
-			return {
-				filepath: filePath,
-				kind: dep.kind,
-				position: dep.position,
-				attributes: dep.attributes,
-				inline: dep.inline,
-				excludeFromHtml: dep.excludeFromHtml,
-			};
-		});
-	}
-
-	private resolveModulePath(importPath: string, rootDir: string): string {
-		if (path.isAbsolute(importPath) && fileSystem.exists(importPath)) {
-			return importPath;
-		}
-
-		try {
-			return getAppBuildAdapter(this.appConfig).resolve(importPath, rootDir);
-		} catch {
-			return this.resolveModulePathFallback(importPath, rootDir);
-		}
-	}
-
-	private resolveModulePathFallback(importPath: string, rootDir: string, maxDepth = 5): string {
-		let currentDir = rootDir;
-		let remainingDepth = maxDepth;
-
-		while (remainingDepth >= 0) {
-			const modulePath = path.join(currentDir, 'node_modules', importPath);
-			if (fileSystem.exists(modulePath)) {
-				return modulePath;
-			}
-
-			const parentDir = path.dirname(currentDir);
-			if (parentDir === currentDir) {
-				break;
-			}
-
-			currentDir = parentDir;
-			remainingDepth -= 1;
-		}
-
-		throw new Error(`Could not resolve module '${importPath}' from '${rootDir}'`);
-	}
-}

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

@@ -1,27 +0,0 @@
-import path from 'node:path';
-import { fileSystem } from '@ecopages/file-system';
-import type { ContentStylesheetAsset, ProcessedAsset } from '../../assets.types';
-import { BaseProcessor } from '../base/base-processor';
-
-export class ContentStylesheetProcessor extends BaseProcessor<ContentStylesheetAsset> {
-	async process(dep: ContentStylesheetAsset): Promise<ProcessedAsset> {
-		const hash = this.generateHash(dep.content);
-		const filename = `style-${hash}.css`;
-		const cachekey = this.buildCacheKey(filename, hash, dep);
-
-		return this.getOrProcess(cachekey, () => {
-			const filepath = path.join(this.getAssetsDir(), 'styles', filename);
-
-			if (!dep.inline) fileSystem.write(filepath, dep.content);
-
-			return {
-				filepath: dep.inline ? undefined : filepath,
-				content: dep.inline ? dep.content : undefined,
-				kind: 'stylesheet',
-				position: dep.position,
-				attributes: dep.attributes,
-				inline: dep.inline,
-			};
-		});
-	}
-}

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

@@ -1,80 +0,0 @@
-import path from 'node:path';
-import { fileSystem } from '@ecopages/file-system';
-import type { FileStylesheetAsset, ProcessedAsset } from '../../assets.types';
-import { BaseProcessor } from '../base/base-processor';
-
-export class FileStylesheetProcessor extends BaseProcessor<FileStylesheetAsset> {
-	private static readonly PROCESSABLE_STYLESHEET_EXTENSIONS = new Set(['.css', '.scss', '.sass', '.less']);
-
-	getStyleContent = (srcUrl: string): Buffer => {
-		return fileSystem.readFileAsBuffer(srcUrl);
-	};
-
-	private isProcessableStylesheet(filepath: string): boolean {
-		return FileStylesheetProcessor.PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
-	}
-
-	private async applyStylesheetProcessors(content: string, filepath: string): Promise<string> {
-		if (!this.isProcessableStylesheet(filepath)) {
-			return content;
-		}
-
-		let transformedContent = content;
-
-		for (const processor of this.appConfig.processors.values()) {
-			const hasCapabilities = processor.getAssetCapabilities().length > 0;
-			const canProcessStylesheet = processor.canProcessAsset('stylesheet', filepath);
-
-			if (!canProcessStylesheet && (hasCapabilities || !processor.getName().includes('postcss'))) {
-				continue;
-			}
-
-			if (!processor.matchesFileFilter(filepath)) {
-				continue;
-			}
-
-			const result = await processor.process(transformedContent, filepath);
-
-			if (typeof result === 'string') {
-				transformedContent = result;
-				continue;
-			}
-
-			if (result instanceof Buffer) {
-				transformedContent = result.toString();
-			}
-		}
-
-		return transformedContent;
-	}
-
-	async process(dep: FileStylesheetAsset): Promise<ProcessedAsset> {
-		const buffer = this.getStyleContent(dep.filepath);
-		const rawContent = buffer.toString();
-		const processedContent = await this.applyStylesheetProcessors(rawContent, dep.filepath);
-		const hash = this.generateHash(processedContent);
-		const cachekey = this.buildCacheKey(dep.filepath, hash, dep);
-
-		return this.getOrProcess(cachekey, () => {
-			const filepath = path.join(
-				this.getAssetsDir(),
-				path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath),
-			);
-			const outputBuffer = Buffer.from(processedContent);
-
-			if (!dep.inline) {
-				fileSystem.ensureDir(path.dirname(filepath));
-				fileSystem.write(filepath, outputBuffer);
-			}
-
-			return {
-				filepath: filepath,
-				content: dep.inline ? processedContent : undefined,
-				kind: 'stylesheet',
-				position: dep.position,
-				attributes: dep.attributes,
-				inline: dep.inline,
-			};
-		});
-	}
-}