mikser-io-render-liquid 2.1.0 → 3.0.0

package/README.md

@@ -14,16 +14,21 @@ npm install mikser-io-render-liquid
 
 ```js
 // mikser.config.js
+import { layouts } from 'mikser-io'
+import { renderLiquid } from 'mikser-io-render-liquid'
+
 export default {
-  renderer: 'liquid',
-  'render-liquid': {
-    jsTruthy: true,
-    strictFilters: false
-  }
+  plugins: [
+    layouts(),
+    renderLiquid({
+      jsTruthy: true,
+      strictFilters: false
+    }),
+  ]
 }
 ```
 
-The `render-liquid` config object is passed through to the `Liquid` constructor — see [LiquidJS options](https://liquidjs.com/api/interfaces/LiquidOptions.html). Defaults applied by the plugin:
+The options object is passed through to the `Liquid` constructor — see [LiquidJS options](https://liquidjs.com/api/interfaces/LiquidOptions.html). Defaults applied by the plugin:
 
 - `root: options.layoutsFolder`
 - `extname: '.liquid'`

package/index.js

@@ -1,7 +1,23 @@
 import { Liquid } from 'liquidjs'
+import { AsyncLocalStorage } from 'node:async_hooks'
 
 let engine
 
+// Per-render context propagated through LiquidJS's async chain via
+// Node's AsyncLocalStorage. The render() function below sets the
+// context; the wrapped _parsePartialFile / _parseLayoutFile (called
+// by IncludeTag.render, RenderTag.render, LayoutTag.render for each
+// include/render/layout invocation) read it back to report partial
+// usage to the engine.
+const renderContext = new AsyncLocalStorage()
+
+function trackPartial(name) {
+    const ctx = renderContext.getStore()
+    if (!ctx?.track || !ctx.layouts || !name) return
+    const layout = ctx.layouts[name]
+    if (layout?.id) ctx.track.partial(layout.id)
+}
+
 export function load({ runtime, options, config }) {
     if (!engine) {
         // `root` still points at the layouts folder so LiquidJS's own
@@ -16,21 +32,49 @@ export function load({ runtime, options, config }) {
             cache: !options.watch,
             ...config,
         })
+
+        // Wrap LiquidJS's per-invocation partial/layout loaders.
+        // IncludeTag.render and RenderTag.render call
+        // engine._parsePartialFile(filepath, …) for each `{% include %}` /
+        // `{% render %}`; LayoutTag.render calls
+        // engine._parseLayoutFile(filepath, …) for `{% layout %}`.
+        // These fire on every invocation — even when the partial's
+        // parse is cache-hit — so they're the right granularity for
+        // tracking per-render usage.
+        const _parsePartialFile = engine._parsePartialFile.bind(engine)
+        engine._parsePartialFile = function (file, sync, currentFile) {
+            trackPartial(file)
+            return _parsePartialFile(file, sync, currentFile)
+        }
+        const _parseLayoutFile = engine._parseLayoutFile.bind(engine)
+        engine._parseLayoutFile = function (file, sync, currentFile) {
+            trackPartial(file)
+            return _parseLayoutFile(file, sync, currentFile)
+        }
     }
     runtime.liquid = (source, data) => engine.parseAndRender(source, data)
 }
 
-export async function render({ entity, runtime }) {
-    // Expose every function on runtime as a Liquid filter,
-    // so render-helper plugins (markdown, href, ...) keep working without per-plugin glue.
+export async function render({ entity, runtime, state, track }) {
+    // Expose every function on runtime as a Liquid filter, so render-
+    // helper plugins (markdown, href, ...) keep working without per-
+    // plugin glue.
     for (let key in runtime) {
         if (typeof runtime[key] === 'function') {
             engine.registerFilter(key, (input, ...args) => runtime[key](input, ...args))
         }
     }
     const source = entity.layout.content ?? ''
+    const layouts = state?.layouts?.layouts ?? {}
     try {
-        return await runtime.liquid(source, runtime)
+        // Establish the render context BEFORE parsing/rendering. Any
+        // internal partial or layout resolution inherits it through
+        // the async chain and reports the resolved name to the
+        // engine's track via the wrapped methods above.
+        return await renderContext.run(
+            { track, layouts },
+            () => runtime.liquid(source, runtime),
+        )
     } catch (err) {
         // LiquidJS RenderError/ParseError carry a `token` with file/line/col.
         const token = err?.token
@@ -40,3 +84,8 @@ export async function render({ entity, runtime }) {
         throw err
     }
 }
+
+// v9 factory — ADR-0010.
+export function renderLiquid(options = {}) {
+    return { name: options.name ?? 'liquid', options, load, render }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mikser-io-render-liquid",
-  "version": "2.1.0",
+  "version": "3.0.0",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -16,7 +16,7 @@
   },
   "homepage": "https://github.com/almero-digital-marketing/mikser-io-render-liquid#readme",
   "peerDependencies": {
-    "mikser-io": "^7.12.0"
+    "mikser-io": "^9.0.0"
   },
   "dependencies": {
     "liquidjs": "^10.27.0"