@ecopages/core 0.2.0-alpha.26 → 0.2.0-alpha.27

package/src/hmr/strategies/js-hmr-strategy.test.ts

@@ -0,0 +1,334 @@
+import { describe, expect, it, beforeAll, afterAll } from 'vitest';
+import { JsHmrStrategy, type JsHmrContext } from './js-hmr-strategy';
+import { HmrStrategyType } from '../hmr-strategy';
+import { InMemoryDevGraphService, NoopDevGraphService } from '../../services/runtime-state/dev-graph.service.ts';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const TMP_DIR = path.join(os.tmpdir(), 'js-hmr-strategy-test');
+const SRC_DIR = path.join(TMP_DIR, 'src');
+
+function createMockContext(overrides: Partial<JsHmrContext> = {}): JsHmrContext {
+	return {
+		getWatchedFiles: () => new Map(),
+		getEntrypointDependencyGraph: () => new NoopDevGraphService(),
+		getDistDir: () => TMP_DIR,
+		getPlugins: () => [],
+		getSrcDir: () => SRC_DIR,
+		getPagesDir: () => path.join(SRC_DIR, 'pages'),
+		getLayoutsDir: () => path.join(SRC_DIR, 'layouts'),
+		getTemplateExtensions: () => ['.tsx'],
+		getBrowserBundleService: () => ({
+			bundle: async () => ({ success: true, logs: [], outputs: [] }),
+		}),
+		...overrides,
+	};
+}
+
+describe('JsHmrStrategy', () => {
+	beforeAll(() => {
+		fs.mkdirSync(SRC_DIR, { recursive: true });
+	});
+
+	afterAll(() => {
+		fs.rmSync(TMP_DIR, { recursive: true, force: true });
+	});
+
+	describe('type', () => {
+		it('has SCRIPT type', () => {
+			const context = createMockContext();
+			const strategy = new JsHmrStrategy(context);
+			expect(strategy.type).toBe(HmrStrategyType.SCRIPT);
+		});
+
+		it('has default priority of 25', () => {
+			const context = createMockContext();
+			const strategy = new JsHmrStrategy(context);
+			expect(strategy.priority).toBe(25);
+		});
+	});
+
+	describe('matches', () => {
+		it('returns false when no watched files are registered', () => {
+			const context = createMockContext({
+				getWatchedFiles: () => new Map(),
+			});
+			const strategy = new JsHmrStrategy(context);
+
+			expect(strategy.matches(path.join(SRC_DIR, 'app.ts'))).toBe(false);
+		});
+
+		it('returns false for unrelated .ts files when dependency graph support is available', () => {
+			const devGraphService = new InMemoryDevGraphService();
+			const context = createMockContext({
+				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
+				getEntrypointDependencyGraph: () => devGraphService,
+			});
+			const strategy = new JsHmrStrategy(context);
+
+			expect(strategy.matches(path.join(SRC_DIR, 'component.ts'))).toBe(false);
+		});
+
+		it('returns true for dependency-connected .tsx files in src directory', () => {
+			const changedFile = path.join(SRC_DIR, 'component.tsx');
+			const devGraphService = new InMemoryDevGraphService();
+			devGraphService.setEntrypointDependencies(path.join(SRC_DIR, 'entry.ts'), [changedFile]);
+			const context = createMockContext({
+				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
+				getEntrypointDependencyGraph: () => devGraphService,
+			});
+			const strategy = new JsHmrStrategy(context);
+
+			expect(strategy.matches(changedFile)).toBe(true);
+		});
+
+		it('returns true for registered entrypoints even without dependency graph hits', () => {
+			const entrypoint = path.join(SRC_DIR, 'entry.tsx');
+			const devGraphService = new InMemoryDevGraphService();
+			const context = createMockContext({
+				getWatchedFiles: () => new Map([[entrypoint, '/output.js']]),
+				getEntrypointDependencyGraph: () => devGraphService,
+			});
+			const strategy = new JsHmrStrategy(context);
+
+			expect(strategy.matches(entrypoint)).toBe(true);
+		});
+
+		it('returns true for .js files in src directory', () => {
+			const context = createMockContext({
+				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
+			});
+			const strategy = new JsHmrStrategy(context);
+
+			expect(strategy.matches(path.join(SRC_DIR, 'utils.js'))).toBe(true);
+		});
+
+		it('returns true for .jsx files in src directory', () => {
+			const context = createMockContext({
+				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
+			});
+			const strategy = new JsHmrStrategy(context);
+
+			expect(strategy.matches(path.join(SRC_DIR, 'component.jsx'))).toBe(true);
+		});
+
+		it('returns false for .css files', () => {
+			const context = createMockContext({
+				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
+			});
+			const strategy = new JsHmrStrategy(context);
+
+			expect(strategy.matches(path.join(SRC_DIR, 'styles.css'))).toBe(false);
+		});
+
+		it('returns false for files outside src directory', () => {
+			const context = createMockContext({
+				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
+			});
+			const strategy = new JsHmrStrategy(context);
+
+			expect(strategy.matches('/other/path/file.ts')).toBe(false);
+		});
+
+		it('returns false for integration-owned route template files', () => {
+			const pagesDir = path.join(SRC_DIR, 'pages');
+			const context = createMockContext({
+				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
+				getPagesDir: () => pagesDir,
+				getTemplateExtensions: () => ['.kita.tsx', '.react.tsx'],
+			});
+			const strategy = new JsHmrStrategy(context);
+
+			expect(strategy.matches(path.join(pagesDir, 'index.kita.tsx'))).toBe(false);
+			expect(strategy.matches(path.join(pagesDir, 'home.react.tsx'))).toBe(false);
+		});
+
+		it('returns false for non-extension matches', () => {
+			const context = createMockContext({
+				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
+			});
+			const strategy = new JsHmrStrategy(context);
+
+			expect(strategy.matches(path.join(SRC_DIR, 'data.json'))).toBe(false);
+			expect(strategy.matches(path.join(SRC_DIR, 'readme.md'))).toBe(false);
+		});
+	});
+
+	describe('process', () => {
+		it('returns none when no watched files are registered', async () => {
+			const context = createMockContext({
+				getWatchedFiles: () => new Map(),
+			});
+			const strategy = new JsHmrStrategy(context);
+
+			const action = await strategy.process(path.join(SRC_DIR, 'app.ts'));
+
+			expect(action.type).toBe('none');
+		});
+
+		it('rebuilds only dependency-connected entrypoints when graph hit exists', async () => {
+			const entryA = path.join(SRC_DIR, 'entry-a.ts');
+			const entryB = path.join(SRC_DIR, 'entry-b.ts');
+			const depA = path.join(SRC_DIR, 'shared-a.ts');
+			const setEntrypointDependenciesCalls: Array<{ entrypointPath: string; dependencies: string[] }> = [];
+			let batchedEntrypoints: string[] = [];
+			const devGraphService = new InMemoryDevGraphService();
+			devGraphService.setEntrypointDependencies(entryA, [depA]);
+			devGraphService.setEntrypointDependencies(entryB, [entryB]);
+
+			const context = createMockContext({
+				getWatchedFiles: () =>
+					new Map([
+						[entryA, '/_hmr/entry-a.js'],
+						[entryB, '/_hmr/entry-b.js'],
+					]),
+				getEntrypointDependencyGraph: () => ({
+					supportsSelectiveInvalidation: () => devGraphService.supportsSelectiveInvalidation(),
+					getDependencyEntrypoints: (filePath: string) => devGraphService.getDependencyEntrypoints(filePath),
+					setEntrypointDependencies: (entrypointPath: string, dependencies: string[]) => {
+						setEntrypointDependenciesCalls.push({ entrypointPath, dependencies });
+						devGraphService.setEntrypointDependencies(entrypointPath, dependencies);
+					},
+					clearEntrypointDependencies: (entrypointPath: string) =>
+						devGraphService.clearEntrypointDependencies(entrypointPath),
+					reset: () => devGraphService.reset(),
+				}),
+			});
+
+			const strategy = new JsHmrStrategy(context) as unknown as {
+				process: (filePath: string) => Promise<{ type: string; events?: unknown[] }>;
+				[key: string]: unknown;
+			};
+
+			strategy.bundleEntrypoints = async (entrypoints: string[]) => {
+				batchedEntrypoints = entrypoints;
+				const dependencies = new Map<string, string[]>();
+				for (const ep of entrypoints) {
+					dependencies.set(path.resolve(ep), [ep, depA]);
+				}
+				return { success: true, dependencies };
+			};
+
+			strategy.processOutput = async () => {
+				return { success: true, requiresReload: false };
+			};
+
+			const action = await strategy.process(depA);
+
+			expect(batchedEntrypoints).toEqual([entryA]);
+			expect(setEntrypointDependenciesCalls).toEqual([{ entrypointPath: entryA, dependencies: [entryA, depA] }]);
+			expect(action).toEqual({
+				type: 'broadcast',
+				events: [
+					{
+						type: 'update',
+						path: '/_hmr/entry-a.js',
+						timestamp: expect.any(Number),
+					},
+				],
+			});
+		});
+
+		it('falls back to rebuilding all watched entrypoints when graph has no hit', async () => {
+			const entryA = path.join(SRC_DIR, 'entry-a.ts');
+			const entryB = path.join(SRC_DIR, 'entry-b.ts');
+			const changedFile = path.join(SRC_DIR, 'new-shared.ts');
+			let batchedEntrypoints: string[] = [];
+
+			const context = createMockContext({
+				getWatchedFiles: () =>
+					new Map([
+						[entryA, '/_hmr/entry-a.js'],
+						[entryB, '/_hmr/entry-b.js'],
+					]),
+				getEntrypointDependencyGraph: () => new NoopDevGraphService(),
+			});
+
+			const strategy = new JsHmrStrategy(context) as unknown as {
+				process: (filePath: string) => Promise<{ type: string; events?: unknown[] }>;
+				[key: string]: unknown;
+			};
+
+			strategy.bundleEntrypoints = async (entrypoints: string[]) => {
+				batchedEntrypoints = entrypoints;
+				const dependencies = new Map<string, string[]>();
+				for (const ep of entrypoints) {
+					dependencies.set(path.resolve(ep), [ep]);
+				}
+				return { success: true, dependencies };
+			};
+
+			strategy.processOutput = async () => {
+				return { success: true, requiresReload: false };
+			};
+
+			const action = await strategy.process(changedFile);
+
+			expect(batchedEntrypoints).toEqual([entryA, entryB]);
+			expect(action).toEqual({
+				type: 'broadcast',
+				events: [
+					{
+						type: 'update',
+						path: '/_hmr/entry-a.js',
+						timestamp: expect.any(Number),
+					},
+					{
+						type: 'update',
+						path: '/_hmr/entry-b.js',
+						timestamp: expect.any(Number),
+					},
+				],
+			});
+		});
+
+		it('skips watched entrypoints owned by higher-priority integration strategies', async () => {
+			const reactEntrypoint = path.join(SRC_DIR, 'react-page.tsx');
+			const scriptEntrypoint = path.join(SRC_DIR, 'widget.script.ts');
+			const changedFile = path.join(SRC_DIR, 'shared.ts');
+			let batchedEntrypoints: string[] = [];
+			const devGraphService = new InMemoryDevGraphService();
+			devGraphService.setEntrypointDependencies(reactEntrypoint, [changedFile]);
+			devGraphService.setEntrypointDependencies(scriptEntrypoint, [changedFile]);
+
+			const context = createMockContext({
+				getWatchedFiles: () =>
+					new Map([
+						[reactEntrypoint, '/_hmr/react-page.js'],
+						[scriptEntrypoint, '/_hmr/widget.script.js'],
+					]),
+				getEntrypointDependencyGraph: () => devGraphService,
+				shouldProcessEntrypoint: (entrypointPath: string) => entrypointPath !== reactEntrypoint,
+			});
+
+			const strategy = new JsHmrStrategy(context) as unknown as {
+				process: (filePath: string) => Promise<{ type: string; events?: unknown[] }>;
+				[key: string]: unknown;
+			};
+
+			strategy.bundleEntrypoints = async (entrypoints: string[]) => {
+				batchedEntrypoints = entrypoints;
+				return { success: true, dependencies: new Map([[path.resolve(scriptEntrypoint), [scriptEntrypoint]]]) };
+			};
+
+			strategy.processOutput = async () => {
+				return { success: true, requiresReload: false };
+			};
+
+			const action = await strategy.process(changedFile);
+
+			expect(batchedEntrypoints).toEqual([scriptEntrypoint]);
+			expect(action).toEqual({
+				type: 'broadcast',
+				events: [
+					{
+						type: 'update',
+						path: '/_hmr/widget.script.js',
+						timestamp: expect.any(Number),
+					},
+				],
+			});
+		});
+	});
+});

package/src/hmr/strategies/js-hmr-strategy.ts

@@ -0,0 +1,314 @@
+/**
+ * JavaScript HMR Strategy
+ *
+ * Handles hot module replacement for JavaScript and TypeScript entrypoints.
+ * Bundles files, inspects the emitted output, and decides whether the browser
+ * can hot-accept the change or must reload.
+ *
+ * @module
+ */
+
+import path from 'node:path';
+import { fileSystem } from '@ecopages/file-system';
+import { HmrStrategy, HmrStrategyType, type HmrAction } from '../hmr-strategy.ts';
+import { appLogger } from '../../global/app-logger.ts';
+import type { EcoBuildPlugin } from '../../build/build-types.ts';
+import type { BrowserBundleExecutor } from '../../services/assets/browser-bundle.service.ts';
+import type { EntrypointDependencyGraph } from '../../services/runtime-state/entrypoint-dependency-graph.service.ts';
+
+/**
+ * Context interface providing access to HmrManager state.
+ * Required for JsHmrStrategy to access registered entrypoints and configuration.
+ */
+export interface JsHmrContext {
+	/**
+	 * Map of registered entrypoints to their output URLs.
+	 */
+	getWatchedFiles(): Map<string, string>;
+
+	getEntrypointDependencyGraph(): EntrypointDependencyGraph;
+
+	/**
+	 * Directory where HMR bundles are written.
+	 */
+	getDistDir(): string;
+
+	/**
+	 * Build plugins to use during bundling.
+	 */
+	getPlugins(): EcoBuildPlugin[];
+
+	/**
+	 * Absolute path to the source directory.
+	 */
+	getSrcDir(): string;
+
+	/**
+	 * Absolute path to the pages directory.
+	 */
+	getPagesDir(): string;
+
+	/**
+	 * Absolute path to the layouts directory.
+	 */
+	getLayoutsDir(): string;
+
+	/**
+	 * All configured route-template extensions across integrations.
+	 */
+	getTemplateExtensions(): string[];
+
+	/**
+	 * Browser bundler used to rebuild changed entrypoints.
+	 */
+	getBrowserBundleService(): BrowserBundleExecutor;
+
+	/**
+	 * Returns whether a watched entrypoint should be rebuilt by the generic JS strategy.
+	 *
+	 * @remarks
+	 * Integrations with higher-priority HMR strategies can use this to keep the
+	 * generic JS strategy from overwriting their emitted entrypoints when a shared
+	 * dependency changes.
+	 */
+	shouldProcessEntrypoint?(entrypointPath: string): boolean;
+}
+
+/**
+ * Strategy for handling JavaScript/TypeScript file changes with hot reloading.
+ *
+ * The processing steps are:
+ * 1. Check if any entrypoints are registered
+ * 2. Rebuild impacted entrypoints, or all watched entrypoints when no runtime
+ *    dependency graph is available
+ * 3. Emit rebuilt entrypoint bundles for browser delivery
+ * 4. Inject generic HMR boilerplate
+ * 5. Broadcast update events for each rebuilt entrypoint
+ *
+ * @remarks
+ * Node can provide dependency-graph metadata, so this strategy can rebuild only
+ * the entrypoints impacted by a changed dependency. Runtimes that do not expose
+ * that metadata intentionally keep the rebuild-all fallback.
+ *
+ * @see https://bun.sh/docs/runtime/transpiler
+ *
+ * @example
+ * ```typescript
+ * const context = {
+ *   getWatchedFiles: () => watchedFilesMap,
+ *   getDistDir: () => '/path/to/dist/_hmr',
+ *   getPlugins: () => [],
+ *   getSrcDir: () => '/path/to/src'
+ * };
+ * const strategy = new JsHmrStrategy(context);
+ * ```
+ */
+export class JsHmrStrategy extends HmrStrategy {
+	readonly type = HmrStrategyType.SCRIPT;
+	private context: JsHmrContext;
+
+	constructor(context: JsHmrContext) {
+		super();
+		this.context = context;
+	}
+
+	/**
+	 * Determines if the file is a JS/TS file that could affect registered entrypoints.
+	 *
+	 * Matches if:
+	 * 1. There are registered entrypoints to rebuild
+	 * 2. The changed file is a JS/TS file in the src directory
+	 *
+	 * @param filePath - Absolute path to the changed file
+	 * @returns True if this file should trigger entrypoint rebuilds
+	 */
+	matches(filePath: string): boolean {
+		const watchedFiles = this.context.getWatchedFiles();
+		const isJsTs = /\.(ts|tsx|js|jsx)$/.test(filePath);
+		const isInSrc = filePath.startsWith(this.context.getSrcDir());
+		const isRouteTemplate =
+			filePath.startsWith(this.context.getPagesDir()) || filePath.startsWith(this.context.getLayoutsDir());
+		const isIntegrationTemplate =
+			isRouteTemplate && this.context.getTemplateExtensions().some((extension) => filePath.endsWith(extension));
+
+		if (watchedFiles.size === 0) {
+			return false;
+		}
+
+		if (!isJsTs || !isInSrc) {
+			return false;
+		}
+
+		if (isIntegrationTemplate) {
+			return false;
+		}
+
+		if (watchedFiles.has(filePath)) {
+			return true;
+		}
+
+		const entrypointDependencyGraph = this.context.getEntrypointDependencyGraph();
+		if (entrypointDependencyGraph.supportsSelectiveInvalidation()) {
+			return entrypointDependencyGraph.getDependencyEntrypoints(filePath).size > 0;
+		}
+
+		return true;
+	}
+
+	/**
+	 * Processes a file change by rebuilding affected entrypoints.
+	 *
+	 * @param filePath - Absolute path to the changed file
+	 *
+	 * @remarks
+	 * If runtime-specific dependency graph hooks are unavailable, this strategy
+	 * falls back to rebuilding all watched entrypoints.
+	 * When multiple entrypoints are impacted they are bundled in a single esbuild
+	 * invocation to share AST parsing and chunk deduplication.
+	 * @returns Action to broadcast update events
+	 */
+	async process(filePath: string): Promise<HmrAction> {
+		appLogger.debug(`[JsHmrStrategy] Processing ${filePath}`);
+		const watchedFiles = this.context.getWatchedFiles();
+
+		if (watchedFiles.size === 0) {
+			appLogger.debug(`[JsHmrStrategy] No watched files to rebuild`);
+			return { type: 'none' };
+		}
+
+		const dependencyHits = this.context.getEntrypointDependencyGraph().getDependencyEntrypoints(filePath);
+		const hasDependencyHit = dependencyHits.size > 0;
+		const impactedEntrypoints = hasDependencyHit
+			? Array.from(dependencyHits).filter((entrypoint) => watchedFiles.has(entrypoint))
+			: Array.from(watchedFiles.keys());
+		const buildableEntrypoints = impactedEntrypoints.filter(
+			(entrypoint) => this.context.shouldProcessEntrypoint?.(entrypoint) ?? true,
+		);
+
+		if (!hasDependencyHit) {
+			appLogger.debug('[JsHmrStrategy] Dependency graph miss, rebuilding all watched entrypoints');
+		}
+
+		if (buildableEntrypoints.length === 0) {
+			return { type: 'none' };
+		}
+
+		const buildResult = await this.bundleEntrypoints(buildableEntrypoints);
+
+		if (!buildResult.success) {
+			return { type: 'none' };
+		}
+
+		const updates: string[] = [];
+		let reloadRequired = false;
+
+		for (const entrypoint of buildableEntrypoints) {
+			const outputUrl = watchedFiles.get(entrypoint);
+			if (!outputUrl) continue;
+
+			if (buildResult.dependencies) {
+				const entrypointDeps = buildResult.dependencies.get(path.resolve(entrypoint)) ?? [];
+				this.context.getEntrypointDependencyGraph().setEntrypointDependencies(entrypoint, entrypointDeps);
+			}
+
+			const srcDir = this.context.getSrcDir();
+			const relativePath = path.relative(srcDir, entrypoint);
+			const relativePathJs = relativePath.replace(/\.(tsx?|jsx?|mdx?)$/, '.js');
+			const outputPath = path.join(this.context.getDistDir(), relativePathJs);
+
+			const result = await this.processOutput(outputPath, outputUrl);
+			if (result.success) {
+				updates.push(outputUrl);
+				if (result.requiresReload) {
+					reloadRequired = true;
+				}
+			}
+		}
+
+		if (updates.length > 0) {
+			if (reloadRequired) {
+				appLogger.debug(`[JsHmrStrategy] Full reload required (no HMR accept found)`);
+				return {
+					type: 'broadcast',
+					events: [{ type: 'reload' }],
+				};
+			}
+
+			return {
+				type: 'broadcast',
+				events: updates.map((p) => ({
+					type: 'update',
+					path: p,
+					timestamp: Date.now(),
+				})),
+			};
+		}
+
+		return { type: 'none' };
+	}
+
+	/**
+	 * Bundles one or more entrypoints in a single esbuild invocation.
+	 * Uses the source directory as the output base so that the directory structure
+	 * is preserved under the HMR dist folder.
+	 */
+	private async bundleEntrypoints(
+		entrypoints: string[],
+	): Promise<{ success: boolean; dependencies?: Map<string, string[]> }> {
+		try {
+			const result = await this.context.getBrowserBundleService().bundle({
+				profile: 'hmr-entrypoint',
+				entrypoints,
+				outdir: this.context.getDistDir(),
+				outbase: this.context.getSrcDir(),
+				naming: '[dir]/[name]',
+				plugins: this.context.getPlugins(),
+				minify: false,
+			});
+
+			if (!result.success) {
+				appLogger.error('[JsHmrStrategy] Batched build failed:', result.logs);
+				return { success: false };
+			}
+
+			const dependencies = new Map<string, string[]>();
+			if (result.dependencyGraph?.entrypoints) {
+				for (const [entrypoint, deps] of Object.entries(result.dependencyGraph.entrypoints)) {
+					dependencies.set(path.resolve(entrypoint), deps);
+				}
+			}
+
+			return { success: true, dependencies };
+		} catch (error) {
+			appLogger.error('[JsHmrStrategy] Error in batched build:', error as Error);
+			return { success: false };
+		}
+	}
+
+	/**
+	 * Processes bundled output and determines whether the browser can hot-accept
+	 * the update or must fall back to a full reload.
+	 *
+	 * @param filepath - Path to the bundled output file
+	 * @param url - URL path for the bundled file
+	 * @returns True if processing was successful and update should be broadcast
+	 */
+	private async processOutput(filepath: string, url: string): Promise<{ success: boolean; requiresReload: boolean }> {
+		try {
+			const code = await fileSystem.readFile(filepath);
+
+			if (code.includes('/* [ecopages] hmr */')) {
+				// Legacy safety: previously processed bundles already carry the marker.
+				return { success: true, requiresReload: !code.includes('import.meta.hot.accept') };
+			}
+
+			appLogger.debug(`[JsHmrStrategy] Processed ${url}`);
+
+			const hasHmrAccept = code.includes('import.meta.hot.accept');
+			return { success: true, requiresReload: !hasHmrAccept };
+		} catch (error) {
+			appLogger.error(`[JsHmrStrategy] Error processing output for ${url}:`, error as Error);
+			return { success: false, requiresReload: false };
+		}
+	}
+}

package/src/index.browser.ts

@@ -0,0 +1,3 @@
+export type * from './types/public-types.ts';
+export type * from './eco/eco.types.ts';
+export { eco } from './eco/eco.browser.ts';

package/src/index.ts

@@ -0,0 +1,15 @@
+export type * from './types/public-types.ts';
+export type * from './eco/eco.types.ts';
+export { eco } from './eco/eco.ts';
+export { defineApiHandler, defineGroupHandler, type GroupHandler } from './adapters/shared/define-api-handler.ts';
+export {
+	createEcoBuildPluginFromSourceTransform,
+	createVitePluginsFromAppSourceTransforms,
+	getAppSourceTransforms,
+	createVitePluginFromSourceTransform,
+	normalizeTransformId,
+	type EcoSourceTransform,
+	type EcoSourceTransformResult,
+	type EcoViteCompatiblePlugin,
+} from './plugins/source-transform.ts';
+export { createEcoComponentMetaTransform } from './plugins/eco-component-meta-plugin.ts';