poops 1.8.0 → 1.9.0

package/README.md

@@ -615,6 +615,34 @@ Both engines support the same feature set (collections, pagination, search index
 
 Both engines process `.html` and `.md` files in addition to their native extension.
 
+#### Templates from an npm package
+
+Layouts and partials can live in an installed package, so a shared theme ships as a dependency instead of copied files. Reference it by package name — any include/extend name containing a `/` is resolved from `node_modules`:
+
+```nunjucks
+{% extends "my-theme/layout.html" %}
+{% block content %}
+  <h1>{{ page.title }}</h1>
+{% endblock %}
+```
+
+Or from front matter, so the page carries no template syntax:
+
+```yaml
+---
+layout: my-theme/layout
+---
+```
+
+A theme package must:
+
+- **Not restrict subpaths with `exports`** — or map its templates explicitly, e.g. `"exports": { "./*": "./*" }`. Otherwise Node blocks resolving the `.html` files by path.
+- **Reference its own partials relatively** — `{% import "./nav.html" as nav %}`, not the bare name. A bare name (no `/`) is always searched in the consumer's project only, never the package.
+
+Bundled filters (`toc`, `breadcrumb`, `og`, `canonical`, …) are engine-global, so package templates use them with no extra wiring.
+
+Liquid resolves package templates the same way — `node_modules` is on its include roots, so `{% layout "my-theme/layout.liquid" %}` and `{% render "my-theme/partial.liquid" %}` resolve by package name too (a Liquid theme ships `.liquid` files). The `exports`/relative-partial rules above apply the same, except containment is by include root rather than the `/` name gate.
+
 #### Custom Engines
 
 The `engine` option also accepts a module specifier — an npm package name or a path relative to your project root. The module's default export must be an engine class:

package/lib/markup/engines/liquid.js

@@ -34,6 +34,16 @@ export default class LiquidEngine {
       }
     } catch { /* ignore */ }
 
+    // Resolve package templates ({% render 'pkg/layout.liquid' %}) from the
+    // consumer's node_modules — parity with the Nunjucks engine. Every ancestor
+    // node_modules on the path is a root, so hoisted/scoped/pnpm installs all
+    // resolve, and liquidjs's containment guard passes without weakening it.
+    // Appended last so project templates always shadow a same-named package one.
+    for (let dir = templatesDir, prev = null; dir !== prev; prev = dir, dir = path.dirname(dir)) {
+      const nm = path.join(dir, 'node_modules')
+      if (fs.existsSync(nm)) roots.push(nm)
+    }
+
     // Dependency index for incremental rebuilds, fed by the recording parse
     // cache below. Persists across compiles; each page render overwrites its
     // own entry.

package/lib/markup/engines/nunjucks.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs'
+import { createRequire } from 'node:module'
 import { globSync } from 'glob'
 import nunjucks from 'nunjucks'
 import path from 'node:path'
@@ -15,6 +16,10 @@ class RelativeLoader extends nunjucks.Loader {
   constructor(templatesDir, includePaths, onTouch) {
     super()
     this.templatesDir = templatesDir
+    // Resolve package templates ({% extends 'pkg/layout.html' %}) from the
+    // consumer project's node_modules. Anchored at templatesDir so resolution
+    // walks up to the project root — also lets a fixture project be used in tests.
+    this.require = createRequire(path.join(templatesDir, 'package.json'))
     // Copy, don't alias+mutate: the caller reuses this array to build the
     // markup glob exclusions, so pushing '_*' here would leak into it.
     this.includePaths = [...(includePaths || []), '_*']
@@ -48,6 +53,14 @@ class RelativeLoader extends nunjucks.Loader {
         pattern = `${this.includePaths[0]}/${pattern}`
       }
       fullPath = globSync(toPosix(path.join(this.templatesDir, pattern)))[0]
+
+      // Not in the project tree — try a package template installed in the
+      // consumer's node_modules, addressed as 'pkg/template.html'. The '/'
+      // gate keeps bare local names (navtree.html) project-only, so this
+      // never fires on the common path.
+      if (!fullPath && name.includes('/')) {
+        try { fullPath = this.require.resolve(name) } catch { /* stays not-found below */ }
+      }
     }
     if (!fullPath || !fs.existsSync(fullPath)) {
       log({ tag: 'markup', error: true, text: 'Template not found:', link: name })

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "poops",
   "description": "Straightforward, no-bullshit bundler for the web.",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "license": "MIT",
   "type": "module",
   "main": "poops.js",