`compile()` preserves include statements, which sort of defeats the point

[Nickersoft]

Is your feature request related to a problem? Please describe.
Yes – seeing I'm using eta with a bundler, I am using compile() along with a custom Vite plugin to convert eta imports into factories that will be bundled with my code. However, I noticed that include statements are preserved as is, which causes a runtime error as there is no views directory specified.

Describe the solution you'd like
I would expect templates to be fully resolved when compiled into factory methods.

Describe alternatives you've considered
Right now I'm exploring using regex to manually inline the partials, but this is less than ideal.

Additional context
N/A

[bgub]

I wonder if there's a way to get the Vite plugin to automatically register the compiled templates w/ Eta? Eta will use a compiled version instead of checking the filesystem if it exists.

[Nickersoft]

With the help of Claude, I managed to adapt the existing Rollup plugin for ETA into one that recursively inlines partials:

import { Eta } from 'eta';
import { createFilter } from '@rollup/pluginutils';
import { readFileSync } from 'fs';
import { dirname, resolve } from 'path';

const defaultPluginOptions = {
	include: ['**/*.eta'],
	exclude: [],
	data: {},
	etaConfig: {}
};

// Regex to match include/includeFile calls: <%~ include("path") %> or <%~ includeFile("path", data) %>
const INCLUDE_REGEX = /<%~\s*(?:E\.)?(?:include|includeFile)\s*\(\s*(['"`])([^'"`]+)\1(?:\s*,\s*[^)]+)?\s*\)\s*%>/g;

/**
 * Recursively resolves all partial includes in a template
 * @param {string} content - Template content
 * @param {string} basePath - Base path for resolving relative includes
 * @param {Set<string>} visited - Set of already visited paths to prevent circular includes
 * @returns {string} - Template with all partials inlined
 */
function resolvePartials(content, basePath, visited = new Set()) {
	return content.replace(INCLUDE_REGEX, (match, _quote, partialPath) => {
		// Resolve the partial path relative to the current template
		let resolvedPath = resolve(dirname(basePath), partialPath);

		// Add .eta extension if not present
		if (!resolvedPath.endsWith('.eta')) {
			resolvedPath += '.eta';
		}

		// Prevent circular includes
		if (visited.has(resolvedPath)) {
			console.warn(`[eta plugin] Circular include detected: ${resolvedPath}`);
			return `<!-- Circular include: ${partialPath} -->`;
		}

		try {
			visited.add(resolvedPath);
			const partialContent = readFileSync(resolvedPath, 'utf-8');
			// Recursively resolve any partials in this partial
			return resolvePartials(partialContent, resolvedPath, visited);
		} catch (err) {
			console.warn(`[eta plugin] Could not resolve partial: ${partialPath} (${resolvedPath})`);
			return match; // Keep original if file not found
		}
	});
}

const ETA_UTILS = `
const escMap = {
    '&': '&amp;',
    '<': '&lt;',
    '>': '&gt;',
    '"': '&quot;',
    "'": '&#39;'
}

function replaceChar(s) {
    return escMap[s]
}

class EtaErr extends Error {}
\n\n`;

/**
 * Vite plugin for Eta templates
 * Adapted from https://github.com/stateful/rollup-plugin-eta/blob/main/src/index.ts
 *
 * @param {Object} config - Plugin configuration
 * @param {string[]} [config.include] - Glob patterns to include
 * @param {string[]} [config.exclude] - Glob patterns to exclude
 * @param {Partial<import('eta').EtaConfig>} [config.etaConfig] - Eta configuration options
 * @returns {import('vite').Plugin}
 */
export default function eta(config = {}) {
	const { include, exclude, data, etaConfig } = { ...defaultPluginOptions, ...config };

	const filter = createFilter(include, exclude);
	const eta = new Eta(etaConfig);

	return {
		name: 'eta',
		transform(code, tplFilePath) {
			if (filter(tplFilePath)) {
				// Resolve all partials before compiling
				const resolvedCode = resolvePartials(code, tplFilePath);
				const templateFn = eta.compile(resolvedCode, etaConfig);
				return {
					code: `export default ${templateFn.toString()}`,
					map: { mappings: '' }
				};
			}
		}
	};
}

Feels very brittle though, despite it working