@apleasantview/eleventy-plugin-baseline 0.1.0-next.8

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cristovao Verstraeten (a pleasant view)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,37 @@
+# Eleventy Plugin Baseline
+
+An experimental Swiss army knife toolkit for Eleventy. Bundles handy helpers for assets, head/meta, navigation, sitemaps, debugging, and more — without turning into a full theme.
+
+## Install
+
+If you already have Eleventy and eleventy-img installed:
+```bash
+npm install @apleasantview/eleventy-plugin-baseline
+```
+
+For a fresh project (install Eleventy and eleventy-img too):
+```bash
+npm install @11ty/eleventy @11ty/eleventy-img @apleasantview/eleventy-plugin-baseline
+```
+
+## Usage
+
+In your Eleventy config (ESM):
+
+```js
+import baseline from "eleventy-plugin-baseline";
+
+export default function (eleventyConfig) {
+	eleventyConfig.addPlugin(baseline, {
+		// verbose: false,
+		// enableNavigatorTemplate: false,
+		// enableSitemapTemplate: true,
+	});
+}
+```
+
+Requires Eleventy 3.x.
+
+## License
+
+MIT. See `LICENSE`.

package/core/debug.js

@@ -0,0 +1,20 @@
+import { inspect as utilInspect } from "node:util";
+
+// Adapted from pdehaan - https://github.com/pdehaan/eleventy-plugin-debug
+const debugOptions = Object.assign({
+  space: 0
+});
+
+function inspect(obj, options = {}) {
+  return utilInspect(obj, options);
+}
+
+function json(obj, space = debugOptions.space) {
+  return JSON.stringify(obj, null, space);
+}
+
+function keys(obj) {
+  return Object.keys(obj).sort();
+}
+
+export default { inspect, json, keys };

package/core/filters/isString.js

@@ -0,0 +1,3 @@
+export default function isStringFilter(object) {
+	return typeof object === "string";
+}

package/core/filters/markdown.js

@@ -0,0 +1,10 @@
+// see https://jeremias.codes/2025/02/markdown-filters-eleventy/
+import markdownit from 'markdown-it';
+
+const md = markdownit({
+	html: true
+});
+
+export const markdownFilter = (string) => {
+  return md.renderInline(string);
+};

package/core/filters/related-posts.js

@@ -0,0 +1,6 @@
+export default function relatedPostsFilter(collection = []) {
+	const page = this.ctx.page;
+	return collection.filter(post => {
+		return post.url !== page.url;
+	})
+} 

package/core/filters.js

@@ -0,0 +1,9 @@
+import { markdownFilter } from "./filters/markdown.js";
+import relatedPostsFilter from "./filters/related-posts.js";
+import isStringFilter from "./filters/isString.js";
+
+export default {
+	markdownFilter,
+	relatedPostsFilter,
+	isStringFilter
+}

package/core/globals/date.js

@@ -0,0 +1,18 @@
+import { DateTime } from "luxon";
+
+/**
+ * Register Nunjucks global "date" with helper methods.
+ * Currently exposes date.toUTCISO(value) -> UTC ISO string without milliseconds.
+ *
+ * @param {import("@11ty/eleventy").UserConfig} eleventyConfig
+ */
+export function registerDateGlobal(eleventyConfig) {
+	eleventyConfig.addNunjucksGlobal("date", {
+		toUTCISO(value) {
+			if (!value) return "";
+			const jsDate = value instanceof Date ? value : new Date(value);
+			if (Number.isNaN(jsDate.getTime())) return "";
+			return DateTime.fromJSDate(jsDate).toUTC().toISO({ suppressMilliseconds: true });
+		}
+	});
+}

package/core/globals.js

@@ -0,0 +1,6 @@
+import { registerDateGlobal } from "./globals/date.js";
+
+/** @param {import("@11ty/eleventy").UserConfig} eleventyConfig */
+export default function registerGlobals(eleventyConfig) {
+	registerDateGlobal(eleventyConfig);
+}

package/core/helpers.js

@@ -0,0 +1,139 @@
+import path from "node:path";
+import { TemplatePath } from "@11ty/eleventy-utils";
+
+/**
+ * Helper function to add trailing slash to a path
+ * @param {string} path
+ * @returns {string}
+ */
+export function addTrailingSlash(path) {
+	if (path.slice(-1) === "/") {
+		return path;
+	}
+	return path + "/";
+}
+
+/**
+ * Resolves the assets directory path from config
+ * Follows Eleventy's pattern: join inputDir + rawDir, then normalize and add trailing slash
+ * @param {string} inputDir - The input directory (e.g., "./src/")
+ * @param {string} rawDir - Raw directory value from config (e.g., "assets")
+ * @returns {{assetsDir: string, assetsDirRelative: string}}
+ */
+export function resolveAssetsDir(inputDir, outputDir, rawDir) {
+	// Join input/output with assets subdir and normalize
+	const joinedInput = TemplatePath.join(inputDir, rawDir || "");
+	const joinedOutput = TemplatePath.join(outputDir, rawDir || "");
+
+	const assetsDir = addTrailingSlash(TemplatePath.standardizeFilePath(joinedInput));
+	const assetsOutputDir = addTrailingSlash(TemplatePath.standardizeFilePath(joinedOutput));
+
+	return {
+		assetsDir,
+		assetsOutputDir,
+	};
+}
+
+/**
+ * Builds glob patterns for fast-glob (absolute paths)
+ * @param {string[]} patterns - User-provided patterns
+ * @param {string} assetsDir - Assets directory (relative, e.g., "./src/assets/")
+ * @returns {string[]} Absolute glob patterns
+ */
+export function buildGlobPatterns(patterns, assetsDir) {
+	const assetsDirAbsolute = TemplatePath.absolutePath(
+		TemplatePath.stripLeadingDotSlash(assetsDir)
+	);
+	
+	return patterns.map((pattern) => {
+		const normalized = TemplatePath.standardizeFilePath(pattern);
+		return normalized.startsWith("/") || path.isAbsolute(normalized)
+			? normalized
+			: TemplatePath.join(assetsDirAbsolute, normalized);
+	});
+}
+
+/**
+ * Extracts file metadata from a file path
+ * @param {string} filePath - Normalized file path
+ * @returns {{basename: string, fileSlug: string, inputFileExtension: string}}
+ */
+export function extractFileMetadata(filePath) {
+	const ext = path.extname(filePath); // Returns extension with dot (e.g., ".css") or ""
+	const inputFileExtension = ext && ext.length > 0 ? ext.slice(1) : "";
+	const basename = TemplatePath.getLastPathSegment(filePath, false);
+	const fileSlug = ext ? basename.slice(0, -ext.length) : basename;
+
+	return { basename, fileSlug, inputFileExtension };
+}
+
+/**
+ * Creates a collection item from a relative file path
+ * @param {string} inputPath - Relative path from project root (e.g., "./src/assets/css/index.css")
+ * @param {string} inputDir - Input directory (e.g., "./src/")
+ * @param {string} outputDir - Output directory (e.g., "./dist/")
+ * @param {string} assetsDirRelative - Assets directory relative to input (e.g., "assets")
+ * @param {string} passthroughOutput - Output path for passthrough
+ * @param {boolean} passthrough - Whether passthrough is enabled
+ * @returns {object} Collection item
+ */
+export function createCollectionItem(
+	inputPath,
+	inputDir,
+	outputDir,
+	assetsDirRelative,
+	passthroughOutput,
+	passthrough
+) {
+	const { basename, fileSlug, inputFileExtension } = extractFileMetadata(inputPath);
+
+	// Get path relative to input directory
+	// e.g., inputPath = "./src/assets/css/index.css", inputDir = "./src/"
+	// relToInput = "assets/css/index.css"
+	const relToInput = TemplatePath.stripLeadingSubPath(
+		inputPath,
+		TemplatePath.addLeadingDotSlash(inputDir)
+	);
+
+	// outputPath: prepend output directory (with leading ./)
+	// e.g., relToInput = "assets/css/index.css", outputDir = "./dist/"
+	// outputPath = "./dist/assets/css/index.css"
+	const outputPath = TemplatePath.addLeadingDotSlash(
+		TemplatePath.normalize(
+			TemplatePath.join(
+				TemplatePath.addLeadingDotSlash(outputDir),
+				relToInput
+			)
+		)
+	);
+
+	// relToAssets: path relative to assets directory for URL generation
+	// e.g., inputPath = "./src/assets/css/index.css", assetsDirRelative = "assets"
+	// relToAssets = "css/index.css"
+	const assetsDirPath = TemplatePath.addLeadingDotSlash(
+		TemplatePath.join(inputDir, assetsDirRelative)
+	);
+	const relToAssets = TemplatePath.stripLeadingSubPath(inputPath, assetsDirPath);
+
+	const url = passthrough
+		? TemplatePath.join(passthroughOutput, relToAssets).replace(/\/$/, "")
+		: undefined;
+
+	// filePathStem: path relative to input without extension, with leading slash
+	// e.g., relToInput = "assets/css/index.css"
+	// filePathStem = "/assets/css/index"
+	const filePathStem = "/" + (inputFileExtension
+		? relToInput.slice(0, -inputFileExtension.length - 1) // Remove extension and dot
+		: relToInput);
+
+	return {
+		inputPath,
+		outputPath,
+		basename,
+		fileSlug,
+		inputFileExtension,
+		filePathStem,
+		dir: TemplatePath.getDirFromFilePath(inputPath),
+		url,
+	};
+}

package/core/logging.js

@@ -0,0 +1,32 @@
+/**
+ * Gets verbose flag from Eleventy global data
+ * @param {import("@11ty/eleventy").UserConfig} eleventyConfig
+ * @returns {boolean}
+ */
+export function getVerbose(eleventyConfig) {
+	const baselineData = eleventyConfig.globalData?._baseline;
+	return !!baselineData?.verbose;
+}
+
+/**
+ * Logs a message if verbose mode is enabled
+ * @param {boolean} verbose - Whether verbose logging is enabled
+ * @param {string} message - Message to log
+ * @param {...any} args - Additional arguments
+ */
+export function logIfVerbose(verbose, message, ...args) {
+	if (verbose) {
+		console.log(`[eleventy-plugin-baseline] INFO ${message}`, ...args);
+	}
+}
+
+/**
+ * Logs a warning if verbose mode is enabled
+ * @param {boolean} verbose - Whether verbose logging is enabled
+ * @param {string} message - Warning message
+ */
+export function warnIfVerbose(verbose, message) {
+	if (verbose) {
+		console.warn(`[eleventy-plugin-baseline] WARN ${message}`);
+	}
+}

package/core/modules.js

@@ -0,0 +1,22 @@
+// Eleventy plugins
+import { EleventyHtmlBasePlugin } from "@11ty/eleventy";
+
+// Custom plugins
+import multilangCore from "../modules/multilang-core/plugins/multilang-core.js";
+import navigatorCore from "../modules/navigator-core/plugins/navigator-core.js";
+import assetsCore from "../modules/assets-core/plugins/assets-core.js";
+import assetsPostCSS from "../modules/assets-postcss/plugins/assets-postcss.js";
+import assetsESBuild from "../modules/assets-esbuild/plugins/assets-esbuild.js";
+import headCore from "../modules/head-core/plugins/head-core.js";
+import sitemapCore from "../modules/sitemap-core/plugins/sitemap-core.js";
+
+export default {
+	EleventyHtmlBasePlugin,
+	multilangCore,
+	navigatorCore,
+	assetsCore,
+	assetsPostCSS,
+	assetsESBuild,
+	headCore,
+	sitemapCore
+};

package/core/shortcodes/image.js

@@ -0,0 +1,120 @@
+import path from "node:path";
+import Image from "@11ty/eleventy-img";
+
+const DEFAULT_WIDTHS = [320, 640, 960, 1280];
+const DEFAULT_FORMATS = ["avif", "webp", "jpeg"];
+const DEFAULT_SIZES = "(max-width: 768px) 100vw, 768px";
+const DEFAULT_OUTPUT = {
+	outputDir: "./dist/media/",
+	urlPath: "/media/",
+};
+
+function pickRenditions(metadata) {
+	// Use the first available format; first entry is smallest, last is largest.
+	const firstFormat = Object.values(metadata)[0];
+	const lowsrc = firstFormat?.[0];
+	const highsrc = firstFormat?.[firstFormat.length - 1];
+	return { lowsrc, highsrc };
+}
+
+/**
+ * Responsive image shortcode using @11ty/eleventy-img.
+ *
+ * @param {Object} options
+ * @param {string} options.src                          Required image source (local or remote).
+ * @param {string} options.alt                          Required alt text (empty string allowed for decorative).
+ * @param {string} [options.caption=""]                 Optional caption; enables figure wrapper when non-empty.
+ * @param {("lazy"|"eager")} [options.loading="lazy"]   Loading behavior.
+ * @param {string} [options.containerClass=""]          Class applied to <picture>.
+ * @param {string} [options.imageClass=""]              Class applied to <img>.
+ * @param {Array<number|string>} [options.widths=DEFAULT_WIDTHS]   Widths passed to eleventy-img.
+ * @param {string} [options.sizes=DEFAULT_SIZES]        Sizes attribute used on sources.
+ * @param {string[]} [options.formats=DEFAULT_FORMATS]  Output formats (order matters).
+ * @param {string} [options.outputDir=DEFAULT_OUTPUT.outputDir] Output directory for generated assets.
+ * @param {string} [options.urlPath=DEFAULT_OUTPUT.urlPath]       Public URL base for generated assets.
+ * @param {Object} [options.attrs={}]                   Extra attributes applied to <img>; `class` merges with imageClass.
+ * @param {boolean} [options.figure=true]               Wrap in <figure> when caption is provided.
+ * @param {boolean} [options.setDimensions=true]        When false, omit width/height on <img>.
+ */
+export async function imageShortcode(options = {}) {
+	const {
+		src,
+		alt,
+		caption = "",
+		loading = "lazy",
+		containerClass = "",
+		imageClass = "",
+		widths = DEFAULT_WIDTHS,
+		sizes = DEFAULT_SIZES,
+		formats = DEFAULT_FORMATS,
+		outputDir = DEFAULT_OUTPUT.outputDir,
+		urlPath = DEFAULT_OUTPUT.urlPath,
+		attrs = {},
+		figure = true,
+		setDimensions = true,
+	} = options;
+
+	if (!src) throw new Error("imageShortcode: src is required");
+	if (alt === undefined) {
+		throw new Error(
+			"imageShortcode: alt is required (use empty string for decorative images)",
+		);
+	}
+
+	const metadata = await Image(src, {
+		widths: [...widths],
+		formats: [...formats],
+		outputDir,
+		urlPath,
+		filenameFormat(id, srcPath, width, format) {
+			const extension = path.extname(srcPath);
+			const name = path.basename(srcPath, extension);
+			return `${name}-${width}w.${format}`;
+		},
+	});
+
+	const { lowsrc, highsrc } = pickRenditions(metadata);
+	if (!lowsrc || !highsrc) {
+		throw new Error(`imageShortcode: no renditions produced for ${src}`);
+	}
+
+	const sourceTags = Object.values(metadata)
+		.map((formatEntries) => {
+			const type = formatEntries[0].sourceType;
+			const srcset = formatEntries.map((entry) => entry.srcset).join(", ");
+			return `<source type="${type}" srcset="${srcset}" sizes="${sizes}">`;
+		})
+		.join("\n");
+
+	const { class: attrClass, ...restAttrs } = attrs;
+	const combinedClass = [imageClass, attrClass].filter(Boolean).join(" ").trim() || undefined;
+
+	const imageAttributes = {
+		src: lowsrc.url,
+		alt,
+		loading,
+		decoding: loading === "eager" ? "sync" : "async",
+		class: combinedClass,
+		...(setDimensions ? { width: highsrc.width, height: highsrc.height } : {}),
+		...restAttrs,
+	};
+
+	const imgAttrString = Object.entries(imageAttributes)
+		.filter(([, value]) => value !== undefined && value !== null && value !== "")
+		.map(([key, value]) => `${key}="${value}"`)
+		.join(" ");
+
+	const pictureClass = containerClass && containerClass.trim() ? ` class="${containerClass.trim()}"` : "";
+
+	const picture = `<picture${pictureClass}>
+	${sourceTags}
+	<img ${imgAttrString}>
+</picture>`;
+
+	if (!figure || !caption) return picture;
+
+	return `<figure>
+	${picture}
+	<figcaption>${caption}</figcaption>
+</figure>`;
+}

package/core/shortcodes.js

@@ -0,0 +1,3 @@
+import { imageShortcode } from "./shortcodes/image.js";
+
+export default { imageShortcode };

package/eleventy.config.js

@@ -0,0 +1,98 @@
+import "dotenv/config";
+import globals from "./core/globals.js";
+import debug from "./core/debug.js";
+import filters from "./core/filters.js";
+import modules from "./core/modules.js";
+import shortcodes from "./core/shortcodes.js";
+
+/**
+ * Eleventy Plugin Baseline.
+ *
+ * @typedef {Object} BaselineOptions
+ * @property {boolean} [verbose=false] Enable extra logging from the plugin.
+ * @property {boolean} [enableNavigatorTemplate=false] Register navigator template/routes.
+ * @property {boolean} [enableSitemapTemplate=true] Register sitemap template/routes.
+ * @property {boolean} [multilingual=false] Enable multilang core (requires defaultLanguage + languages).
+ * @property {string} [defaultLanguage] IETF/BCP47 default language code (used when multilingual=true).
+ * @property {Record<string, unknown>} [languages={}] Language definition map (shape not enforced; only presence/keys checked).
+ *
+ * @param {BaselineOptions} [options={}] Custom options for the plugin.
+ * @returns {(eleventyConfig: UserConfig) => void}
+ */
+export default function baseline(options = {}) {
+	/** @param {import("@11ty/eleventy").UserConfig} eleventyConfig */
+	return async function (eleventyConfig) {
+		try {
+			// Emit a warning message if the application is not using Eleventy 3.0 or newer (including prereleases).
+			eleventyConfig.versionCheck(">=3.0");
+		} catch (e) {
+			console.log(`[eleventy-plugin-baseline] WARN Eleventy plugin compatibility: ${e.message}`);
+		}
+
+		const userOptions = {
+			verbose: options.verbose ?? false,
+			enableNavigatorTemplate: options.enableNavigatorTemplate ?? false,
+			enableSitemapTemplate: options.enableSitemapTemplate ?? true,
+			multilingual: options.multilingual ?? false,
+			...options
+		};
+
+		// Core functions.
+		// Languages are expected as an object map; if missing or invalid, skip.
+		const languages = userOptions.languages && typeof userOptions.languages === "object"
+			? userOptions.languages : null;
+		const hasLanguages = languages && Object.keys(languages).length > 0;
+		const isMultilingual = userOptions.multilingual === true && userOptions.defaultLanguage && hasLanguages;
+
+		eleventyConfig.addGlobalData("_baseline", userOptions);
+		globals(eleventyConfig);
+		eleventyConfig.addPassthroughCopy({ "./src/static": "/" }, { failOnError: true });
+		eleventyConfig.addPreprocessor("drafts", "*", (data, content) => {
+			if (data.draft && process.env.ELEVENTY_RUN_MODE === "build") {
+				return false;
+			}
+		});
+
+		if (isMultilingual) {
+			eleventyConfig.addPlugin(modules.multilangCore, {
+				defaultLanguage: userOptions.defaultLanguage,
+				languages
+			});
+		}
+
+		// Modules.
+		eleventyConfig.addPlugin(modules.EleventyHtmlBasePlugin, { baseHref: process.env.URL || eleventyConfig.pathPrefix });
+		eleventyConfig.addPlugin(modules.assetsCore);
+		eleventyConfig.addPlugin(modules.assetsPostCSS);
+		eleventyConfig.addPlugin(modules.assetsESBuild);
+		eleventyConfig.addPlugin(modules.headCore);
+		eleventyConfig.addPlugin(modules.sitemapCore, { enableSitemapTemplate: userOptions.enableSitemapTemplate, multilingual: isMultilingual, languages });
+
+		// Filters — Module filters might move to their respective module.
+		eleventyConfig.addFilter("markdownify", filters.markdownFilter);
+		eleventyConfig.addFilter("relatedPosts", filters.relatedPostsFilter);
+		eleventyConfig.addFilter("isString", filters.isStringFilter);
+
+		// Shortcodes.
+		eleventyConfig.addShortcode("image", shortcodes.imageShortcode);
+
+		// Debug filters and navigators.
+		eleventyConfig.addFilter("_inspect", debug.inspect);
+		eleventyConfig.addFilter("_json", debug.json);
+		eleventyConfig.addFilter("_keys", debug.keys);
+		eleventyConfig.addPlugin(modules.navigatorCore, { enableNavigatorTemplate: userOptions.enableNavigatorTemplate });
+	};
+}
+
+export const config = {
+	dir: {
+		input: "src",
+		output: "dist",
+		data: "_data",
+		includes: "_includes",
+		assets: "assets"
+	},
+	htmlTemplateEngine: "njk",
+	markdownTemplateEngine: "njk",
+	templateFormats: ["html", "njk", "md"]
+};

package/modules/assets-core/plugins/assets-core.js

@@ -0,0 +1,81 @@
+import { TemplatePath } from "@11ty/eleventy-utils";
+import { addTrailingSlash, resolveAssetsDir } from "../../../core/helpers.js";
+import { warnIfVerbose, getVerbose } from "../../../core/logging.js";
+
+const syncCacheFromDirectories = (cache, dirs, rawDir) => {
+	const inputDir = TemplatePath.addLeadingDotSlash(dirs.input || "./");
+	const outputDir = TemplatePath.addLeadingDotSlash(dirs.output || "./");
+	const { assetsDir, assetsOutputDir } = resolveAssetsDir(inputDir, outputDir, rawDir);
+
+	cache.input = addTrailingSlash(inputDir);
+	cache.output = addTrailingSlash(outputDir);
+	cache.assetsInput = assetsDir;
+	cache.assetsOutput = assetsOutputDir;
+};
+
+const ensureCache = (cache, eleventyConfig, rawDir, verbose) => {
+	if (cache.assetsInput) return;
+	syncCacheFromDirectories(cache, eleventyConfig.dir || {}, rawDir);
+	warnIfVerbose(verbose, "Fallback directory resolution");
+};
+
+/**
+ * eleventy-plugin-assets-core
+ *
+ * Resolve assets input/output directories, register a virtual
+ * `directories.assets`, expose the resolved paths via global data, and add
+ * a watch target under the resolved assets input directory.
+ *
+ * Options:
+ *  - verbose  (boolean, default global baseline verbose): enable verbose logs.
+ */
+/** @param {import("@11ty/eleventy").UserConfig} eleventyConfig */
+export default function assetsCore(eleventyConfig, options = {}) {
+	const verbose = getVerbose(eleventyConfig) || options.verbose || false;
+	const userKey = "assets";
+
+	// Extract raw directory value from config (can be done early)
+	const rawDir = eleventyConfig.dir?.[userKey] || userKey;
+
+	// Cache object (raw values; normalized later by syncCacheFromDirectories)
+	const cache = {
+		input: eleventyConfig.dir?.input || null,
+		output: eleventyConfig.dir?.output || null,
+		assetsInput: eleventyConfig.dir?.assets ?? userKey ?? null,
+		assetsOutput: null,
+	};
+
+	syncCacheFromDirectories(cache, eleventyConfig.dir || {}, rawDir);
+
+	eleventyConfig.on("eleventy.directories", (directories) => {
+		syncCacheFromDirectories(cache, directories, rawDir);
+
+		// Add a virtual directory key only if not already defined/configurable.
+		const existing = Object.getOwnPropertyDescriptor(eleventyConfig.directories, userKey);
+		if (existing && existing.configurable === false) {
+			warnIfVerbose(verbose, `directories[${userKey}] already defined; skipping`);
+			return;
+		}
+
+		Object.defineProperty(eleventyConfig.directories, userKey, {
+			get() {
+				return cache.assetsInput;
+			},
+			enumerable: true,
+			configurable: false,
+		});
+	});
+
+	eleventyConfig.addGlobalData("_baseline.assets", () => {
+		ensureCache(cache, eleventyConfig, rawDir, verbose);
+		return {
+			input: cache.assetsInput,
+			output: cache.assetsOutput
+		};
+	});
+
+	// Watch target — use resolved assets input dir.
+	ensureCache(cache, eleventyConfig, rawDir, verbose);
+	const watchGlob = TemplatePath.join(cache.assetsInput, "**/*.{css,js,svg,png,jpeg}");
+	eleventyConfig.addWatchTarget(watchGlob);
+}

package/modules/assets-esbuild/filters/inline-esbuild.js

@@ -0,0 +1,21 @@
+import fs from "fs/promises";
+import * as esbuild from "esbuild";
+
+export default async function inlineESbuild(jsFilePath) {
+	try {
+		// let jsContent = await fs.readFile(jsFilePath, 'utf8');
+
+		let result = await esbuild.build({
+			entryPoints: [jsFilePath],
+			bundle: true,
+			minify: true,
+			target: "es2020",
+			write: false
+		});
+
+		return `<script>${result.outputFiles[0].text}</script>`;
+	} catch (error) {
+		console.error(error);
+		return `<script>/* Error processing JS */</script>`;
+	}
+}