eleventy-plugin-vento 5.5.0 → 5.5.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # eleventy-plugin-vento
 
+## 5.5.1
+
+### Patch Changes
+
+- 3702292: Partially revert 1087bec127bf569a601cb7afb76230b51f5be652, which introduced a regression causing the package to be published without first being built. (fixes #603)
+
 ## 5.5.0
 
 ### Minor Changes

package/dist/plugin.d.mts

@@ -0,0 +1,66 @@
+import * as ventojs$1 from "ventojs";
+import _UserConfig from "@11ty/eleventy/UserConfig";
+import { Plugin } from "ventojs/core/environment.js";
+//#region src/types/utilities.d.ts
+/**
+ * Matches any given string so autocomplete in literal unions works as expected
+ */
+type AnyString = string & Record<never, never>;
+//#endregion
+//#region src/types/eleventy.d.ts
+interface UserConfig extends _UserConfig {
+  directories: {
+    input: string;
+    output: string;
+    includes: string;
+    layouts: string;
+  };
+}
+//#endregion
+//#region src/types/options.d.ts
+interface PluginOptions {
+  /**
+   * An array of Vento plugins
+   */
+  plugins: Plugin[];
+  /**
+   * Enables Vento's autotrim plugin.
+   * @example
+   * // Set to an array of tags
+   * autotrim: ['tag1', 'tag2']
+   * @example
+   * // Use Vento's defaults and Eleventy paired shortcodes
+   * // Setting `true` is functionally equivalent to both
+   * // `@vento` and `@11ty` being present
+   * autotrim: ['@vento', '@11ty']
+   * autotrim: true
+   */
+  autotrim: ('@11ty' | '@vento' | AnyString)[] | boolean;
+  /**
+   * Enable use of Eleventy filters
+   */
+  filters: boolean;
+  /**
+   * Enable use of Eleventy shortcodes
+   */
+  shortcodes: boolean;
+  /**
+   * Enable use of Eleventy paired shortcodes
+   */
+  pairedShortcodes: boolean;
+  /**
+   * A Vento configuration object.
+   * @see {@link https://vento.js.org/configuration/}
+   * @default
+   * {
+   *   // Defaults to Eleventy's own `includes` directory
+   *   includes: eleventyConfig.directories.includes
+   * }
+   */
+  ventoOptions: ventojs$1.Options;
+}
+//#endregion
+//#region src/plugin.d.ts
+declare function VentoPlugin(eleventyConfig: UserConfig, userOptions?: Partial<PluginOptions>): void;
+//#endregion
+export { VentoPlugin };

package/dist/plugin.mjs

@@ -0,0 +1,257 @@
+import path from "node:path";
+import autotrimPlugin, { defaultTags } from "ventojs/plugins/auto_trim.js";
+import ventojs from "ventojs";
+import { VentoError } from "ventojs/core/errors.js";
+import { styleText } from "node:util";
+import createDebugger from "debug";
+//#region src/utils/create-vento-tag.ts
+function createVentoTag(tagInfo) {
+	let LEVEL = 1;
+	const IS_PAIRED = tagInfo.group === "paired";
+	const tag = (env, token, output, tokens) => {
+		const code = token[1];
+		if (!(code === tagInfo.name || code.startsWith(`${tagInfo.name} `))) return;
+		const { dataVarname } = env.options;
+		const thisArg = `{
+			page: ${dataVarname}.page,
+			eleventy: ${dataVarname}.eleventy
+		}`;
+		const fn = `__env.utils.eleventyFunctions.get('${tagInfo.group}:${tagInfo.name}')`;
+		const args = [code.replace(tagInfo.name, "").trim()];
+		const compiled = [];
+		if (IS_PAIRED) {
+			const nestedVarname = `__content${output.startsWith("__content") ? LEVEL++ : 0}`;
+			args.unshift(env.compileFilters(tokens, nestedVarname, env.options.autoescape));
+			compiled.push("{", `let ${nestedVarname} = "";`, ...env.compileTokens(tokens, nestedVarname, `/${tagInfo.name}`));
+		}
+		args.unshift(thisArg);
+		compiled.push("{", `const __result = await ${fn}.call(${args.filter(Boolean).join(", ")});`, `${output} += ${env.compileFilters(tokens, "__result", env.options.autoescape)}`, "}");
+		if (IS_PAIRED) compiled.push("}");
+		return compiled.join("\n");
+	};
+	return Object.defineProperty(tag, "name", { value: `${tagInfo.name}_${IS_PAIRED ? `EleventyPairedTag` : `EleventyTag`}` });
+}
+//#endregion
+//#region src/utils/logging.ts
+const debug = {
+	main: createDebugger("Eleventy:Vento"),
+	get cache() {
+		return this.main.extend("Cache");
+	},
+	get render() {
+		return this.main.extend("Render");
+	},
+	get error() {
+		return this.main.extend("Error");
+	}
+};
+function warn(...messages) {
+	for (const message of messages) console.error(styleText("gray", "[warning]"), styleText("yellow", message));
+}
+//#endregion
+//#region src/utils/errors.ts
+const LINE_TERMINATOR = /(\r\n?|[\n\u{2028}\u{2029}])/u;
+var EleventyVentoError = class extends Error {
+	static async createFromContext(error) {
+		const ctx = await error.getContext();
+		const err = new this("An unknown error occured processing Vento templates", ctx, error);
+		if (ctx.position === void 0 || ctx.file === void 0) warn(`A \`${ctx.type}\` was thrown, but the exact position within the source code cannot be obtained`, "Use DEBUG=\"Eleventy:Vento*\" to view raw `ErrorContext` information");
+		debug.error("Received `ErrorContext` from Vento: %O", ctx);
+		if (ctx.file === void 0) return err;
+		err.message = `${ctx.type} in ${ctx.file}`;
+		if (ctx.position === void 0 || ctx.source === void 0) return err;
+		const sourceLines = codeToLines(ctx.source);
+		const [sourceLine, sourceColumn] = locateInCode(sourceLines, ctx.position);
+		err.message += `:${sourceLine}:${sourceColumn}:\n\n`;
+		const pad = sourceLine.toString().length;
+		const indent = " ".repeat(pad);
+		for (let line = Math.max(sourceLine - 3, 1); line <= sourceLine; line++) err.message += `${String(line).padStart(pad)} │ ${sourceLines[line - 1].trimEnd()}\n`;
+		err.message += `${indent}   ${" ".repeat(sourceColumn - 1)}^`;
+		if (!ctx.code || ctx.line === void 0 || ctx.column === void 0) return err;
+		const codelines = codeToLines(ctx.code);
+		err.message += `\n\n${indent} │ /// compiled Vento function for ${ctx.file} ///\n${indent} │ ${codelines[ctx.line - 1].trimEnd()}\n${indent}   ${" ".repeat(ctx.column - 1)}^`;
+		return err;
+	}
+	constructor(message, context, cause) {
+		super(message, { cause });
+		this.context = context;
+	}
+};
+/**
+* Converts a code string to an array of lines
+*/
+function codeToLines(code) {
+	const doubleLines = code.split(LINE_TERMINATOR);
+	const lines = [];
+	for (let i = 0; i < doubleLines.length; i += 2) lines.push(`${doubleLines[i]}${doubleLines[i + 1] ?? ""}`);
+	return lines;
+}
+/**
+* Identifies the line/column location from a character index
+*/
+function locateInCode(lines, position) {
+	if (position < 0) return [1, 1];
+	let index = 0;
+	for (const [line, content] of lines.entries()) {
+		const { length } = content;
+		if (position < index + length) return [line + 1, position - index + 1];
+		index += length;
+	}
+	throw new Error(`Positon ${position} is out of bounds for the provided source`);
+}
+//#endregion
+//#region src/engine.ts
+function createVentoEngine(options) {
+	const env = ventojs(options);
+	/**
+	* Load plugins into Vento environment
+	*/
+	function loadPlugins(plugins) {
+		for (const plugin of plugins) env.use(plugin);
+	}
+	/**
+	* Load filters into Vento environment
+	*/
+	function loadFilters(filters) {
+		for (const [name, fn] of Object.entries(filters)) env.filters[name] = function(...args) {
+			const { page, eleventy } = this.data;
+			return fn.apply({
+				...this,
+				page,
+				eleventy
+			}, args);
+		};
+	}
+	/**
+	* Load shortcodes (tags) into Vento environment
+	*/
+	function loadShortcodes(group, shortcodes) {
+		if (!(env.utils.eleventyFunctions instanceof Map)) env.utils.eleventyFunctions = /* @__PURE__ */ new Map();
+		for (const [name, fn] of Object.entries(shortcodes)) {
+			env.utils.eleventyFunctions.set(`${group}:${name}`, fn);
+			env.tags.push(createVentoTag({
+				name,
+				group
+			}));
+		}
+	}
+	/**
+	* Clear one or more items from Vento's cache
+	*/
+	function removeCachedItems(items) {
+		for (let item of items) {
+			item = path.normalize(item);
+			debug.cache("Delete cache entry for %s", item);
+			env.cache.delete(item);
+		}
+	}
+	/**
+	* Given a source string and file, compile or get a cached template function,
+	* then produce an Eleventy render function for it and return it.
+	*/
+	async function getRenderFunction(source, file, options) {
+		debug.main("Getting render function for `%s`", file);
+		let template = await env.cache.get(file);
+		if (template?.source === source) debug.cache("Cache HIT for `%s`, using precompiled template", file);
+		else {
+			try {
+				debug.cache("Cache MISS for `%s`, will compile new template function", file);
+				template = env.compile(source, file);
+			} catch (error) {
+				if (error instanceof VentoError) throw await EleventyVentoError.createFromContext(error);
+				throw error;
+			}
+			if (options?.cache !== false) env.cache.set(file, template);
+		}
+		const render = async (data) => {
+			try {
+				debug.render("Rendering %s", file);
+				const { content } = await template(data);
+				return content;
+			} catch (error) {
+				if (error instanceof VentoError) throw await EleventyVentoError.createFromContext(error);
+				throw error;
+			}
+		};
+		return render;
+	}
+	return {
+		loadPlugins,
+		loadFilters,
+		loadShortcodes,
+		removeCachedItems,
+		getRenderFunction
+	};
+}
+//#endregion
+//#region src/plugin.ts
+function VentoPlugin(eleventyConfig, userOptions) {
+	debug.main("Initializing eleventy-plugin-vento");
+	eleventyConfig.versionCheck(">=3.0.0");
+	const options = {
+		autotrim: false,
+		plugins: [],
+		filters: true,
+		shortcodes: true,
+		pairedShortcodes: true,
+		ventoOptions: { includes: eleventyConfig.directories.includes },
+		...userOptions
+	};
+	debug.main("Merged default and user config: %O", options);
+	const filters = eleventyConfig.getFilters();
+	debug.main("Reading filters from Eleventy: %o", filters);
+	const shortcodes = eleventyConfig.getShortcodes();
+	debug.main("Reading shortcodes from Eleventy: %o", shortcodes);
+	const pairedShortcodes = eleventyConfig.getPairedShortcodes();
+	debug.main("Reading paired shortcodes from Eleventy: %o", pairedShortcodes);
+	if (options.autotrim) {
+		const tagSet = new Set(options.autotrim === true ? ["@vento", "@11ty"] : options.autotrim);
+		if (tagSet.has("@vento")) {
+			tagSet.delete("@vento");
+			for (const name of defaultTags) tagSet.add(name);
+		}
+		if (tagSet.has("@11ty")) {
+			tagSet.delete("@11ty");
+			for (const name in pairedShortcodes) tagSet.add(name);
+		}
+		debug.main("Enabled autotrim for tags: %o", tagSet);
+		options.plugins.push(autotrimPlugin({ tags: [...tagSet] }));
+	}
+	debug.main("Initializing Vento environment");
+	const engine = createVentoEngine(options.ventoOptions);
+	debug.main("Loading plugins: %o", options.plugins);
+	engine.loadPlugins(options.plugins);
+	if (options.filters) {
+		debug.main("Loading filters: %o", filters);
+		engine.loadFilters(filters);
+	}
+	if (options.shortcodes) {
+		debug.main("Loading shortcodes: %o", shortcodes);
+		engine.loadShortcodes("single", shortcodes);
+	}
+	if (options.pairedShortcodes) {
+		debug.main("Loading paired shortcodes: %o", pairedShortcodes);
+		engine.loadShortcodes("paired", pairedShortcodes);
+	}
+	debug.main("Adding Vento cache handler for eleventy.beforeWatch event");
+	eleventyConfig.on("eleventy.beforeWatch", engine.removeCachedItems);
+	debug.main("Registering .vto as a template format");
+	eleventyConfig.addTemplateFormats("vto");
+	debug.main("Registering .vto extension with eleventy");
+	eleventyConfig.addExtension("vto", {
+		outputFileExtension: "html",
+		read: true,
+		async compile(inputContent, inputPath) {
+			inputPath = path.normalize(inputPath);
+			return await engine.getRenderFunction(inputContent, inputPath, { cache: false });
+		},
+		compileOptions: { async permalink(permalinkContent, inputPath) {
+			if (typeof permalinkContent !== "string" || !/\{\{\s+.+\s+\}\}/.test(permalinkContent)) return permalinkContent;
+			inputPath = `EleventyVentoDynamicPermalink:${path.normalize(inputPath)}`;
+			return await engine.getRenderFunction(permalinkContent, inputPath);
+		} }
+	});
+	debug.main("eleventy-plugin-vento initialized");
+}
+//#endregion
+export { VentoPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eleventy-plugin-vento",
-  "version": "5.5.0",
+  "version": "5.5.1",
   "description": "Adds support for the Vento templating language to Eleventy.",
   "type": "module",
   "engines": {
@@ -54,7 +54,7 @@
     "globals": "17.7.0",
     "knip": "6.26.0",
     "prettier": "3.9.5",
-    "tsdown": "0.22.4",
+    "tsdown": "0.22.7",
     "typescript": "6.0.3",
     "typescript-eslint": "8.63.0",
     "vitest": "4.1.10"