eleventy-plugin-edgejs 1.0.0 → 1.1.1

package/README.md

@@ -12,6 +12,9 @@ npm install eleventy-plugin-edgejs
 
 ## Usage
 
+> [!TIP]
+> This repository includes a working Eleventy site with more template and syntax examples. Browse the [example source](./example) or see the [Example Site](#example-site) section for instructions on running it locally.
+
 Register the plugin in your Eleventy config file:
 
 ```js
@@ -281,6 +284,19 @@ In your layout file (`_includes/layout.edge`):
 </html>
 ```
 
+## Example Site
+
+This repository includes a working Eleventy site with more template and syntax examples. To run it locally:
+
+```sh
+git clone https://github.com/reverentgeek/eleventy-plugin-edgejs.git
+cd eleventy-plugin-edgejs
+npm install
+npm run start:example
+```
+
+This starts a local dev server so you can browse the examples and experiment with Edge.js templates.
+
 ## Further Reading
 
 - [Edge.js documentation](https://edgejs.dev/)

package/edgeJsPlugin.js

@@ -1,4 +1,103 @@
-import { Edge } from "edge.js";
+import { Edge, Template } from "edge.js";
+
+// Sentinel prefix for async placeholders (uses null byte to avoid collisions with real content)
+const ASYNC_PREFIX = "\0__EDGE_ASYNC_";
+const ASYNC_SUFFIX = "__\0";
+const ASYNC_PATTERN = /\0__EDGE_ASYNC_(\d+)__\0/g;
+
+// Patch Template.prototype.escape to:
+// 1. Render null/undefined as empty string (matches Nunjucks, Handlebars, Liquid, Mustache)
+// 2. Detect unresolved Promises and defer resolution via placeholders
+const _originalEscape = Template.prototype.escape;
+
+Template.prototype.escape = function ( input ) {
+	// Convert null/undefined to empty string instead of "null"/"undefined"
+	if ( input == null ) return "";
+
+	// Detect unresolved Promises from async filters/shortcodes
+	if ( typeof input === "object" && typeof input.then === "function" ) {
+		if ( !this.__pendingPromises ) {
+			this.__pendingPromises = [];
+		}
+		const idx = this.__pendingPromises.length;
+		this.__pendingPromises.push( input );
+		return `${ ASYNC_PREFIX }${ idx }${ ASYNC_SUFFIX }`;
+	}
+
+	return _originalEscape.call( this, input );
+};
+
+// Patch Template.prototype.renderRaw to resolve async placeholders after rendering
+const _originalRenderRaw = Template.prototype.renderRaw;
+
+Template.prototype.renderRaw = function ( contents, state, templatePath ) {
+	this.__pendingPromises = [];
+
+	const result = _originalRenderRaw.call( this, contents, state, templatePath );
+
+	// Async mode returns a Promise
+	if ( result && typeof result.then === "function" ) {
+		return result.then( output => resolveAsyncPlaceholders( this, output ) );
+	}
+
+	return result;
+};
+
+// Patch Template.prototype.reThrow to preserve the original error as .cause.
+// Edge.js discards the original error class when wrapping in EdgeError, which breaks
+// Eleventy's two-pass rendering system — it can't detect TemplateContentPrematureUseError
+// and fails instead of deferring the template to a second pass.
+const _originalReThrow = Template.prototype.reThrow;
+
+Template.prototype.reThrow = function ( error, filename, lineNumber ) {
+	try {
+		_originalReThrow.call( this, error, filename, lineNumber );
+	} catch ( wrapped ) {
+		if ( wrapped !== error ) {
+			wrapped.cause = error;
+		}
+		throw wrapped;
+	}
+};
+
+// Patch Template.prototype.render for includes/components that may also contain async calls
+const _originalRender = Template.prototype.render;
+
+Template.prototype.render = function ( template, state ) {
+	if ( !this.__pendingPromises ) {
+		this.__pendingPromises = [];
+	}
+
+	const result = _originalRender.call( this, template, state );
+
+	if ( result && typeof result.then === "function" ) {
+		return result.then( output => resolveAsyncPlaceholders( this, output ) );
+	}
+
+	return result;
+};
+
+async function resolveAsyncPlaceholders( template, output ) {
+	if ( !template.__pendingPromises || template.__pendingPromises.length === 0 ) {
+		return output;
+	}
+
+	const resolved = await Promise.all( template.__pendingPromises );
+	template.__pendingPromises = [];
+
+	output = output.replace( ASYNC_PATTERN, ( _, idx ) => {
+		const val = resolved[parseInt( idx )];
+		if ( val == null ) return "";
+		return _originalEscape.call( template, val );
+	} );
+
+	// Check if resolving introduced new placeholders (unlikely but possible with nested async)
+	if ( ASYNC_PATTERN.test( output ) ) {
+		return resolveAsyncPlaceholders( template, output );
+	}
+
+	return output;
+}
 
 export default function edgeJsPlugin( eleventyConfig, options = {} ) {
 	eleventyConfig.versionCheck( ">=3.0.0" );

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "eleventy-plugin-edgejs",
-	"version": "1.0.0",
+	"version": "1.1.1",
 	"description": "Eleventy plugin for Edge.js templating",
 	"type": "module",
 	"main": "edgeJsPlugin.js",
@@ -47,4 +47,4 @@
 		"eslint": "^10.0.2",
 		"eslint-config-reverentgeek": "^7.0.3"
 	}
-}
+}