@ecopages/core 0.2.0-alpha.7 → 0.2.0-alpha.8

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

@@ -1,385 +0,0 @@
-import { afterEach, beforeEach, expect, test, vi } from 'vitest';
-import { fileSystem } from '@ecopages/file-system';
-import { AssetProcessingService } from './asset-processing.service';
-import type { AssetDefinition } from './assets.types';
-
-const Config = {
-	absolutePaths: {
-		distDir: '/test/dist',
-	},
-} as any;
-
-const Processor = {
-	process: async () => ({
-		filepath: '/test/dist/assets/test.js',
-		kind: 'script',
-		inline: false,
-	}),
-};
-
-const originalEnsureDirectoryExists = fileSystem.ensureDir;
-const originalGzipDir = fileSystem.gzipDir;
-const originalWrite = fileSystem.write;
-const originalReadFileSync = fileSystem.readFileSync;
-const originalRemove = fileSystem.remove;
-const originalExists = fileSystem.exists;
-
-beforeEach(() => {
-	fileSystem.ensureDir = vi.fn(() => {});
-	fileSystem.gzipDir = vi.fn(() => {});
-	fileSystem.write = vi.fn(() => {});
-	fileSystem.readFileSync = vi.fn(() => Buffer.from('') as any);
-	fileSystem.remove = vi.fn(() => {});
-	fileSystem.exists = vi.fn(() => false);
-});
-
-afterEach(() => {
-	fileSystem.ensureDir = originalEnsureDirectoryExists;
-	fileSystem.gzipDir = originalGzipDir;
-	fileSystem.write = originalWrite;
-	fileSystem.readFileSync = originalReadFileSync;
-	fileSystem.remove = originalRemove;
-	fileSystem.exists = originalExists;
-	vi.restoreAllMocks();
-});
-
-test('AssetProcessingService - registerProcessor', () => {
-	const service = new AssetProcessingService(Config);
-	service.registerProcessor('script', 'file', Processor);
-	expect(service.getRegistry().getProcessor('script', 'file')).toBeDefined();
-});
-
-test('AssetProcessingService - processDependencies', async () => {
-	const service = AssetProcessingService.createWithDefaultProcessors(Config);
-	const results = await service.processDependencies(
-		[
-			{
-				kind: 'script',
-				source: 'content',
-				content: 'console.log("test")',
-				bundle: false,
-			} as AssetDefinition,
-		],
-		'test-key',
-	);
-
-	expect(results.length).toBe(1);
-	expect((results[0] as any).key).toBe('test-key');
-});
-
-test('AssetProcessingService - createWithDefaultProcessors', () => {
-	const service = AssetProcessingService.createWithDefaultProcessors(Config);
-	expect([...service.getRegistry().getAllProcessors().values()].length).toBeGreaterThan(0);
-});
-
-test('AssetProcessingService - processDependencies - success', async () => {
-	const ensureDirMock = vi.fn(() => {});
-	const gzipDirMock = vi.fn(() => {});
-	fileSystem.ensureDir = ensureDirMock;
-	fileSystem.gzipDir = gzipDirMock;
-	fileSystem.exists = vi.fn(() => true);
-
-	const service = new AssetProcessingService(Config);
-	const Processor1 = {
-		process: vi.fn(async () => ({
-			filepath: '/test/dist/assets/script.js',
-			kind: 'script',
-			inline: false,
-		})),
-	};
-	const Processor2 = {
-		process: vi.fn(async () => ({
-			filepath: '/test/dist/assets/style.css',
-			kind: 'stylesheet',
-			inline: false,
-		})),
-	};
-	service.registerProcessor('script', 'file', Processor1);
-	service.registerProcessor('stylesheet', 'file', Processor2);
-
-	const dependencies: AssetDefinition[] = [
-		{ kind: 'script', source: 'file', filepath: 'path/to/script.js' },
-		{ kind: 'stylesheet', source: 'file', filepath: 'path/to/style.css' },
-	];
-	const key = 'test-page';
-
-	const results = await service.processDependencies(dependencies, key);
-
-	expect(ensureDirMock).toHaveBeenCalledWith('/test/dist/assets');
-	expect(Processor1.process).toHaveBeenCalledTimes(1);
-	expect(Processor2.process).toHaveBeenCalledTimes(1);
-	expect(results.length).toBe(2);
-
-	expect(results[0]).toEqual(
-		expect.objectContaining({
-			filepath: '/test/dist/assets/script.js',
-			kind: 'script',
-			inline: false,
-			srcUrl: '/assets/script.js',
-		}),
-	);
-	expect(results[1]).toEqual(
-		expect.objectContaining({
-			filepath: '/test/dist/assets/style.css',
-			kind: 'stylesheet',
-			inline: false,
-			srcUrl: '/assets/style.css',
-		}),
-	);
-
-	expect(gzipDirMock).not.toHaveBeenCalled();
-});
-
-test('AssetProcessingService - processDependencies - processor not found', async () => {
-	const ensureDirMock = vi.fn(() => {});
-	const gzipDirMock = vi.fn(() => {});
-
-	fileSystem.ensureDir = ensureDirMock;
-	fileSystem.gzipDir = gzipDirMock;
-
-	const service = new AssetProcessingService(Config);
-
-	const dependencies: AssetDefinition[] = [{ kind: 'script', source: 'content', content: 'alert(1)' }];
-	const key = 'test-key-missing';
-
-	const results = await service.processDependencies(dependencies, key);
-
-	expect(ensureDirMock).toHaveBeenCalledWith('/test/dist/assets');
-	expect(results.length).toBe(0);
-	expect(gzipDirMock).not.toHaveBeenCalled();
-});
-
-test('AssetProcessingService - processDependencies - error during processing', async () => {
-	const ensureDirMock = vi.fn(() => {});
-	const gzipDirMock = vi.fn(() => {});
-	fileSystem.ensureDir = ensureDirMock;
-	fileSystem.gzipDir = gzipDirMock;
-	fileSystem.exists = vi.fn(() => true);
-
-	const service = new AssetProcessingService(Config);
-	const erroringProcessor = {
-		process: vi.fn(async () => {
-			throw new Error('Processing failed!');
-		}),
-	};
-	service.registerProcessor('script', 'file', erroringProcessor);
-
-	const dependency: AssetDefinition = {
-		kind: 'script',
-		source: 'file',
-		filepath: 'path/to/failing.js',
-	};
-	const key = 'test-key-error';
-
-	const results = await service.processDependencies([dependency], key);
-
-	expect(ensureDirMock).toHaveBeenCalledWith('/test/dist/assets');
-	expect(erroringProcessor.process).toHaveBeenCalledTimes(1);
-	expect(results.length).toBe(0);
-	expect(gzipDirMock).not.toHaveBeenCalled();
-});
-
-test('AssetProcessingService - processDependencies - handles undefined filepath for srcUrl', async () => {
-	const ensureDirMock = vi.fn(() => {});
-	const gzipDirMock = vi.fn(() => {});
-	fileSystem.ensureDir = ensureDirMock;
-	fileSystem.gzipDir = gzipDirMock;
-
-	const service = new AssetProcessingService(Config);
-	const ProcessorInline = {
-		process: vi.fn(async () => ({
-			kind: 'script',
-			inline: true,
-			content: 'console.log("inline");',
-		})),
-	};
-	service.registerProcessor('script', 'content', ProcessorInline);
-
-	const dependencies: AssetDefinition[] = [
-		{ kind: 'script', source: 'content', content: 'console.log("inline");', inline: true },
-	];
-	const key = 'test-inline';
-
-	const results = await service.processDependencies(dependencies, key);
-
-	expect(ensureDirMock).toHaveBeenCalledWith('/test/dist/assets');
-	expect(ProcessorInline.process).toHaveBeenCalledTimes(1);
-	expect(results.length).toBe(1);
-
-	expect(results[0]).toEqual(
-		expect.objectContaining({
-			kind: 'script',
-			inline: true,
-			content: 'console.log("inline");',
-			srcUrl: undefined,
-		}),
-	);
-
-	expect(gzipDirMock).not.toHaveBeenCalled();
-});
-
-test('AssetProcessingService - processDependencies - normalizes absolute srcUrl to public assets path', async () => {
-	fileSystem.ensureDir = vi.fn(() => {});
-	fileSystem.gzipDir = vi.fn(() => {});
-	fileSystem.exists = vi.fn(() => true);
-
-	const service = new AssetProcessingService(Config);
-	const processor = {
-		process: vi.fn(async () => ({
-			srcUrl: '/test/dist/assets/scripts/module--tanstack-react-table.js',
-			kind: 'script',
-			inline: false,
-		})),
-	};
-	service.registerProcessor('script', 'file', processor);
-
-	const dependency: AssetDefinition = { kind: 'script', source: 'file', filepath: 'path/to/module.js' };
-
-	const results = await service.processDependencies([dependency], 'normalize-src-url-key');
-
-	expect(processor.process).toHaveBeenCalledTimes(1);
-	expect(results.length).toBe(1);
-	expect(results[0].srcUrl).toBe('/assets/scripts/module--tanstack-react-table.js');
-});
-
-test('AssetProcessingService - caching returns cached asset without reprocessing', async () => {
-	fileSystem.ensureDir = vi.fn(() => {});
-	fileSystem.gzipDir = vi.fn(() => {});
-	fileSystem.exists = vi.fn(() => true);
-
-	const service = new AssetProcessingService(Config);
-	const processMock = vi.fn(async () => ({
-		filepath: '/test/dist/assets/cached.js',
-		kind: 'script',
-		inline: false,
-	}));
-	service.registerProcessor('script', 'file', { process: processMock });
-
-	const dependency: AssetDefinition = { kind: 'script', source: 'file', filepath: 'path/to/cached.js' };
-
-	const results1 = await service.processDependencies([dependency], 'key1');
-	const results2 = await service.processDependencies([dependency], 'key2');
-
-	expect(processMock).toHaveBeenCalledTimes(1);
-	expect(results1.length).toBe(1);
-	expect(results2.length).toBe(1);
-	expect(results1[0].srcUrl).toBe('/assets/cached.js');
-	expect(results2[0].srcUrl).toBe('/assets/cached.js');
-});
-
-test('AssetProcessingService - stale cached emitted files are rebuilt when output is missing', async () => {
-	fileSystem.ensureDir = vi.fn(() => {});
-	fileSystem.gzipDir = vi.fn(() => {});
-	const existsMock = vi
-		.fn()
-		.mockImplementationOnce(() => true)
-		.mockImplementationOnce(() => false)
-		.mockImplementation(() => true);
-	fileSystem.exists = existsMock;
-
-	const service = new AssetProcessingService(Config);
-	const processMock = vi.fn(async () => ({
-		filepath: '/test/dist/assets/stale.js',
-		kind: 'script',
-		inline: false,
-	}));
-	service.registerProcessor('script', 'file', { process: processMock });
-
-	const dependency: AssetDefinition = { kind: 'script', source: 'file', filepath: 'path/to/stale.js' };
-
-	await service.processDependencies([dependency], 'key1');
-	await service.processDependencies([dependency], 'key2');
-
-	expect(processMock).toHaveBeenCalledTimes(2);
-});
-
-test('AssetProcessingService - deduplication processes duplicate deps only once', async () => {
-	fileSystem.ensureDir = vi.fn(() => {});
-	fileSystem.gzipDir = vi.fn(() => {});
-	fileSystem.exists = vi.fn(() => true);
-
-	const service = new AssetProcessingService(Config);
-	const processMock = vi.fn(async () => ({
-		filepath: '/test/dist/assets/dedup.js',
-		kind: 'script',
-		inline: false,
-	}));
-	service.registerProcessor('script', 'file', { process: processMock });
-
-	const dependency: AssetDefinition = { kind: 'script', source: 'file', filepath: 'path/to/dedup.js' };
-	const duplicateDeps = [dependency, dependency, dependency];
-
-	const results = await service.processDependencies(duplicateDeps, 'dedup-key');
-
-	expect(processMock).toHaveBeenCalledTimes(1);
-	expect(results.length).toBe(1);
-});
-
-test('AssetProcessingService - clearCache clears all cached assets', async () => {
-	fileSystem.ensureDir = vi.fn(() => {});
-	fileSystem.gzipDir = vi.fn(() => {});
-	fileSystem.exists = vi.fn(() => true);
-
-	const service = new AssetProcessingService(Config);
-	const processMock = vi.fn(async () => ({
-		filepath: '/test/dist/assets/clear.js',
-		kind: 'script',
-		inline: false,
-	}));
-	service.registerProcessor('script', 'file', { process: processMock });
-
-	const dependency: AssetDefinition = { kind: 'script', source: 'file', filepath: 'path/to/clear.js' };
-
-	await service.processDependencies([dependency], 'key1');
-	expect(processMock).toHaveBeenCalledTimes(1);
-
-	service.clearCache();
-
-	await service.processDependencies([dependency], 'key2');
-	expect(processMock).toHaveBeenCalledTimes(2);
-});
-
-test('AssetProcessingService - invalidateCacheForFile removes specific file from cache', async () => {
-	fileSystem.ensureDir = vi.fn(() => {});
-	fileSystem.gzipDir = vi.fn(() => {});
-	fileSystem.exists = vi.fn(() => true);
-
-	const service = new AssetProcessingService(Config);
-	const processMock = vi.fn(async () => ({
-		filepath: '/test/dist/assets/invalidate.js',
-		kind: 'script',
-		inline: false,
-	}));
-	service.registerProcessor('script', 'file', { process: processMock });
-
-	const dependency: AssetDefinition = { kind: 'script', source: 'file', filepath: 'path/to/invalidate.js' };
-
-	await service.processDependencies([dependency], 'key1');
-	expect(processMock).toHaveBeenCalledTimes(1);
-
-	service.invalidateCacheForFile('/test/dist/assets/invalidate.js');
-
-	await service.processDependencies([dependency], 'key2');
-	expect(processMock).toHaveBeenCalledTimes(2);
-});
-
-test('AssetProcessingService - skips missing file dependencies', async () => {
-	fileSystem.ensureDir = vi.fn(() => {});
-	fileSystem.gzipDir = vi.fn(() => {});
-	fileSystem.exists = vi.fn(() => false);
-
-	const service = new AssetProcessingService(Config);
-	const processMock = vi.fn(async () => ({
-		filepath: '/test/dist/assets/missing.js',
-		kind: 'script',
-		inline: false,
-	}));
-	service.registerProcessor('script', 'file', { process: processMock });
-
-	const dependency: AssetDefinition = { kind: 'script', source: 'file', filepath: 'path/to/missing.js' };
-
-	const results = await service.processDependencies([dependency], 'missing-key');
-
-	expect(processMock).not.toHaveBeenCalled();
-	expect(results.length).toBe(0);
-});

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

@@ -1,63 +0,0 @@
-import { expect, test } from 'vitest';
-import { AssetFactory } from './asset.factory';
-
-test('AssetFactory - createInlineScriptAsset', () => {
-	const asset = AssetFactory.createInlineContentScript({
-		content: 'console.log("test")',
-	});
-	expect(asset.kind).toBe('script');
-	expect(asset.source).toBe('content');
-	expect(asset.inline).toBe(true);
-	expect(asset.position).toBe('body');
-});
-
-test('AssetFactory - createSrcScriptAsset', () => {
-	const asset = AssetFactory.createFileScript({
-		filepath: 'https://test.com/script.js',
-	});
-	expect(asset.kind).toBe('script');
-	expect(asset.source).toBe('file');
-});
-
-test('AssetFactory - createJsonAssetScript', () => {
-	const asset = AssetFactory.createJsonScript({
-		content: '{"test": true}',
-	});
-	expect(asset.kind).toBe('script');
-	expect(asset.source).toBe('content');
-	expect(asset.attributes?.type).toBe('application/json');
-});
-
-test('AssetFactory - createInlineStylesheetAsset', () => {
-	const asset = AssetFactory.createInlineContentStylesheet({
-		content: 'body { color: red; }',
-	});
-	expect(asset.kind).toBe('stylesheet');
-	expect(asset.source).toBe('content');
-	expect(asset.position).toBe('head');
-});
-
-test('AssetFactory - createContentScript', () => {
-	const asset = AssetFactory.createContentScript({
-		content: 'console.log("test")',
-	});
-	expect(asset.kind).toBe('script');
-	expect(asset.source).toBe('content');
-	expect(asset.position).toBe('body');
-});
-
-test('AssetFactory - createInlineContentScript', () => {
-	const asset = AssetFactory.createInlineContentScript({
-		content: 'console.log("test")',
-	});
-	expect(asset.inline).toBe(true);
-	expect(asset.source).toBe('content');
-});
-
-test('AssetFactory - createFileScript', () => {
-	const asset = AssetFactory.createFileScript({
-		filepath: '/path/to/script.js',
-	});
-	expect(asset.kind).toBe('script');
-	expect(asset.source).toBe('file');
-});

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

@@ -1,72 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { test } from 'vitest';
-import {
-	BROWSER_RUNTIME_SCRIPT_ATTRIBUTES,
-	buildBrowserRuntimeAssetUrl,
-	createBrowserRuntimeModuleAsset,
-	createBrowserRuntimeScriptAsset,
-} from './browser-runtime-asset.factory.ts';
-
-test('buildBrowserRuntimeAssetUrl uses the vendors asset directory', () => {
-	assert.equal(buildBrowserRuntimeAssetUrl('react.js'), '/assets/vendors/react.js');
-});
-
-test('createBrowserRuntimeScriptAsset creates a hidden head runtime bundle asset', () => {
-	const plugin = { name: 'runtime-plugin', setup() {} };
-	const asset = createBrowserRuntimeScriptAsset({
-		importPath: '/tmp/react-entry.mjs',
-		name: 'react',
-		fileName: 'react.js',
-		bundleOptions: {
-			plugins: [plugin],
-		},
-	});
-
-	assert.deepEqual(asset, {
-		kind: 'script',
-		source: 'node-module',
-		position: 'head',
-		importPath: '/tmp/react-entry.mjs',
-		name: 'react',
-		excludeFromHtml: true,
-		bundleOptions: {
-			naming: 'react.js',
-			plugins: [plugin],
-		},
-		attributes: BROWSER_RUNTIME_SCRIPT_ATTRIBUTES,
-	});
-});
-
-test('createBrowserRuntimeModuleAsset creates an entry module and hidden runtime asset together', () => {
-	const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'eco-browser-runtime-asset-'));
-	fs.writeFileSync(path.join(rootDir, 'package.json'), '{}', 'utf8');
-	fs.mkdirSync(path.join(rootDir, 'node_modules', 'runtime-a'), { recursive: true });
-	fs.writeFileSync(
-		path.join(rootDir, 'node_modules', 'runtime-a', 'index.js'),
-		"module.exports = { default: 'runtime-a', alpha: 'a' };",
-		'utf8',
-	);
-
-	try {
-		const asset = createBrowserRuntimeModuleAsset({
-			rootDir,
-			cacheDirName: 'ecopages-browser-runtime-test',
-			modules: [{ specifier: 'runtime-a', defaultExport: true }],
-			name: 'runtime-a',
-			fileName: 'runtime-a.js',
-		});
-
-		assert.equal(asset.source, 'node-module');
-		assert.equal(
-			asset.importPath.endsWith(path.join('ecopages-browser-runtime-test', 'runtime-a-entry.mjs')),
-			true,
-		);
-		assert.equal(asset.bundleOptions?.naming, 'runtime-a.js');
-		assert.equal(asset.excludeFromHtml, true);
-	} finally {
-		fs.rmSync(rootDir, { recursive: true, force: true });
-	}
-});

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

@@ -1,67 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
-import { test } from 'vitest';
-import { createBrowserRuntimeEntryModule } from './browser-runtime-entry.factory.ts';
-
-test('createBrowserRuntimeEntryModule writes a shared runtime entry file', () => {
-	const rootDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-browser-runtime-entry-'));
-	fs.writeFileSync(path.join(rootDir, 'package.json'), '{}', 'utf8');
-
-	try {
-		const filePath = createBrowserRuntimeEntryModule({
-			rootDir,
-			cacheDirName: 'ecopages-react-runtime-test',
-			fileName: 'runtime-entry.mjs',
-			modules: [{ specifier: 'node:path' }, { specifier: 'node:fs' }],
-		});
-
-		assert.equal(path.basename(filePath), 'runtime-entry.mjs');
-		assert.equal(
-			filePath,
-			path.join(rootDir, 'node_modules', '.cache', 'ecopages-react-runtime-test', 'runtime-entry.mjs'),
-		);
-
-		const contents = fs.readFileSync(filePath, 'utf8');
-		assert.match(contents, /export \{ .*basename.* \} from 'node:path';/);
-		assert.match(contents, /export \{ .*readFileSync.* \} from 'node:fs';/);
-	} finally {
-		fs.rmSync(rootDir, { recursive: true, force: true });
-	}
-});
-
-test('createBrowserRuntimeEntryModule preserves a default export and deduplicates named exports', () => {
-	const rootDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-browser-runtime-entry-'));
-	fs.writeFileSync(path.join(rootDir, 'package.json'), '{}', 'utf8');
-	fs.mkdirSync(path.join(rootDir, 'node_modules', 'runtime-a'), { recursive: true });
-	fs.mkdirSync(path.join(rootDir, 'node_modules', 'runtime-b'), { recursive: true });
-	fs.writeFileSync(
-		path.join(rootDir, 'node_modules', 'runtime-a', 'index.js'),
-		"module.exports = { default: 'runtime-a', alpha: 'a', shared: 'shared-a' };",
-		'utf8',
-	);
-	fs.writeFileSync(
-		path.join(rootDir, 'node_modules', 'runtime-b', 'index.js'),
-		"module.exports = { beta: 'b', shared: 'shared-b' };",
-		'utf8',
-	);
-
-	try {
-		const filePath = createBrowserRuntimeEntryModule({
-			rootDir,
-			cacheDirName: 'ecopages-react-runtime-test',
-			fileName: 'runtime-entry.mjs',
-			modules: [{ specifier: 'runtime-a', defaultExport: true }, { specifier: 'runtime-b' }],
-		});
-
-		const contents = fs.readFileSync(filePath, 'utf8');
-		assert.match(contents, /import __ecopages_default_export__ from 'runtime-a';/);
-		assert.match(contents, /export default __ecopages_default_export__;/);
-		assert.match(contents, /export \{ alpha, shared \} from 'runtime-a';/);
-		assert.match(contents, /export \{ beta \} from 'runtime-b';/);
-		assert.doesNotMatch(contents, /export \{ .*shared.* \} from 'runtime-b';/);
-	} finally {
-		fs.rmSync(rootDir, { recursive: true, force: true });
-	}
-});

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

@@ -1,59 +0,0 @@
-import { afterEach, beforeEach, expect, test, vi } from 'vitest';
-import { fileSystem } from '@ecopages/file-system';
-import type { BaseAsset, ProcessedAsset } from '../../assets.types.ts';
-import { BaseProcessor } from './base-processor.ts';
-
-type TestAsset = BaseAsset & {
-	name: string;
-};
-
-class TestProcessor extends BaseProcessor<TestAsset> {
-	processCalls = 0;
-
-	async process(dep: TestAsset): Promise<ProcessedAsset> {
-		return this.getOrProcess(dep.name, async () => {
-			this.processCalls += 1;
-			return {
-				filepath: `/test/dist/assets/${dep.name}.js`,
-				kind: dep.kind,
-				inline: false,
-			};
-		});
-	}
-}
-
-const originalExists = fileSystem.exists;
-
-beforeEach(() => {
-	fileSystem.exists = vi.fn(() => true);
-});
-
-afterEach(() => {
-	fileSystem.exists = originalExists;
-	vi.restoreAllMocks();
-});
-
-test('BaseProcessor - rebuilds cached outputs when emitted file was deleted', async () => {
-	const existsMock = vi
-		.fn()
-		.mockImplementationOnce(() => false)
-		.mockImplementation(() => true);
-	fileSystem.exists = existsMock;
-
-	const processor = new TestProcessor({
-		appConfig: {
-			absolutePaths: { distDir: '/test/dist' },
-		} as any,
-	});
-
-	const asset: TestAsset = {
-		kind: 'script',
-		source: 'file',
-		name: 'runtime-vendor',
-	};
-
-	await processor.process(asset);
-	await processor.process(asset);
-
-	expect(processor.processCalls).toBe(2);
-});