mikser-io-render-liquid 2.0.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,37 +1,80 @@
 import { Liquid } from 'liquidjs'
-import path from 'node:path'
+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
+        // `{% include 'partial' %}` / `{% layout 'wrapper' %}`
+        // directives can resolve from disk. The top-level layout body
+        // is rendered from `entity.layout.content` (populated by the
+        // layouts plugin and stripped of YAML by front-matter) —
+        // single source of truth for layout bodies.
         engine = new Liquid({
             root: options.layoutsFolder,
             extname: '.liquid',
             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 = (name, data) => engine.renderFile(name, data)
+    runtime.liquid = (source, data) => engine.parseAndRender(source, data)
 }
 
-export async function render({ entity, options, 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))
         }
     }
-    // Keep the `.liquid` in the name. LiquidJS's renderFile resolution
-    // skips its own `extname` append for names that already have a
-    // file-ish extension — and `path.extname('foo.html-pdf')` is
-    // `.html-pdf`, which Liquid treats as "extension already present".
-    // Stripping would make multi-segment layout names (e.g.
-    // `franchises.html-pdf.liquid`) fail with ENOENT.
-    const name = path.relative(options.layoutsFolder, entity.layout.uri)
+    const source = entity.layout.content ?? ''
+    const layouts = state?.layouts?.layouts ?? {}
     try {
-        return await runtime.liquid(name, 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
@@ -41,3 +84,8 @@ export async function render({ entity, options, 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.0.0",
+  "version": "3.0.0",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -16,9 +16,9 @@
   },
   "homepage": "https://github.com/almero-digital-marketing/mikser-io-render-liquid#readme",
   "peerDependencies": {
-    "mikser-io": "^7.0.0"
+    "mikser-io": "^9.0.0"
   },
   "dependencies": {
-    "liquidjs": "^10.16.0"
+    "liquidjs": "^10.27.0"
   }
 }