@webhandle/tripartite-renderer 1.0.0

package/README.md

@@ -0,0 +1,21 @@
+# @webhandle/tripartite-renderer
+
+Adds tripartite rendering support to webhandle. It addes a rendering engine
+if express is set up and modifies the response to render with tripartite templates
+(if they exist) directly to the response instead of having to buffer the output.
+
+
+## Install
+
+```bash
+npm install @webhandle/tripartite-renderer
+```
+
+## Usage
+
+Run after express has been configured.
+
+```js
+import setupTripartiteRenderer from '@webhandle/tripartite-renderer/setup-tripartite-renderer.mjs'
+setupTripartiteRenderer(webhandleInstance)
+```

package/determine-template-name.mjs

@@ -0,0 +1,15 @@
+export default function determineTemplateName(filePath, viewPaths) {
+	for(let viewPath of viewPaths) {
+		if(filePath.startsWith(viewPath)) {
+			let name = filePath.substring(viewPath.length)
+			if(name.startsWith('/')) {
+				name = name.substring(1)
+			}
+			if(name.endsWith('.tri')) {
+				name = name.substring(0, name.length - 4)
+			}
+			return name
+		}
+	}
+	return filePath
+}

package/initialize-webhandle-component.mjs

@@ -0,0 +1,19 @@
+import createInitializeWebhandleComponent from "@webhandle/initialize-webhandle-component/create-initialize-webhandle-component.mjs"
+import ComponentManager from "@webhandle/initialize-webhandle-component/component-manager.mjs"
+import setupTripartiteRenderer from "./setup-tripartite-renderer.mjs"
+
+let initializeWebhandleComponent = createInitializeWebhandleComponent()
+
+initializeWebhandleComponent.componentName = '@webhandle/tripartite-renderer'
+initializeWebhandleComponent.componentDir = import.meta.dirname
+initializeWebhandleComponent.defaultConfig = {}
+initializeWebhandleComponent.staticFilePaths = ['public']
+initializeWebhandleComponent.templatePaths = ['views']
+
+initializeWebhandleComponent.setup = async function(webhandle, config) {
+	let manager = new ComponentManager()
+	setupTripartiteRenderer(webhandle)
+	return manager
+}
+
+export default initializeWebhandleComponent

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@webhandle/tripartite-renderer",
+  "version": "1.0.0",
+  "description": "",
+  "main": "setup-tripartite-renderer.mjs",
+  "scripts": {
+    "test": "node test/all.mjs"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "module",
+  "dependencies": {
+    "@webhandle/initialize-webhandle-component": "^1.0.1",
+    "file-sink": "^1.0.15",
+    "filter-log": "^1.0.13",
+    "tripartite": "^1.1.5"
+  },
+  "devDependencies": {
+    "@webhandle/express-5": "^1.0.0"
+  }
+  , "files": [
+	"README.md"
+	, "*.mjs"
+  ]
+}

package/setup-tripartite-renderer.mjs

@@ -0,0 +1,124 @@
+import filterLog from 'filter-log'
+import tripartite from 'tripartite'
+let log = filterLog('webhandle', { component: 'tripartite render' })
+let tri = tripartite
+import createCachingLoader from '@webhandle/core/lib/loaders/create-caching-loader.mjs'
+import determineTemplateName from './determine-template-name.mjs'
+import createTripartiteFileLoader from "@webhandle/core/lib/loaders/create-tripartite-template-loader.mjs"
+import FileSink from 'file-sink'
+
+export default function setupTripartiteRenderer(webhandle) {
+	webhandle.tripartiteTemplateLoaders = []
+	webhandle.tripartite = tri
+
+	webhandle.addTemplateDir = function (path, { immutable } = {}) {
+		let absPath = webhandle.getAbsolutePathFromProjectRelative(path)
+		let sink = new FileSink(absPath)
+		let loader = createTripartiteFileLoader(sink)
+		
+		if(immutable === undefined) {
+			immutable = !webhandle.development
+		}
+		
+		if(immutable) {
+			loader = createCachingLoader(loader, {})
+		}
+		this.tripartiteTemplateLoaders.push(loader)
+		let info = {
+			loader, sink, path: absPath, immutable
+		}
+		return info
+	}
+
+	webhandle.createScopedTripartite = function () {
+		let scoped = tri.createBlank()
+		scoped.loaders = this.tripartiteTemplateLoaders.map(loader => createCachingLoader(loader, {}))
+		scoped.dataFunctions = Object.assign({}, tri.dataFunctions)
+
+		if (this.app) {
+			let viewPaths = this.app.get('views')
+			if(viewPaths && Array.isArray(viewPaths) === false) {
+				viewPaths = [viewPaths]
+			}
+			for (let viewPath of viewPaths) {
+				let absPath = webhandle.getAbsolutePathFromProjectRelative(viewPath)
+				let sink = new FileSink(absPath)
+				let loader = createTripartiteFileLoader(sink)
+				scoped.loaders.push(loader)
+			}
+		}
+
+		return scoped
+	}
+
+	if (webhandle.app && webhandle.app.engine) {
+		
+		// define the template engine
+		webhandle.app.engine('tri', async (filePath, options, callback) => { 
+			let triInstance = webhandle.createScopedTripartite()
+			let absViewPaths = webhandle.app.get('views').map(view => webhandle.getAbsolutePathFromProjectRelative(view))
+			let name = determineTemplateName(filePath, absViewPaths)
+			triInstance.loadTemplate(name, function (template) {
+				if (template) {
+					let data = options || {}
+					template(data, function (err, content) {
+						if (err) {
+							log.error(err)
+						}
+						if (callback) {
+							return callback(content)
+						}
+					})
+				}
+				else {
+					if (callback) {
+						return callback()
+					}
+				}
+			})
+		})
+
+		// register the template engine
+		webhandle.app.set('view engine', 'tri') 
+	}
+
+	function changeResponseForTripartite(req, res, next) {
+		try {
+			res.oldInternalRender = res.internalRender
+
+			let resTri = res.tri = webhandle.createScopedTripartite()
+			resTri.dataFunctions.externalResources = res.externalResources
+
+			res.internalRender = function (name, data, callback, destination) {
+				resTri.loadTemplate(name, function (template) {
+					if (template) {
+						data = data || res.locals
+						template(data, destination, function (err) {
+							if (err) {
+								log.error(err)
+							}
+							try {
+								destination.end()
+							}
+							catch (e) {
+								log.error(e)
+							}
+							if (callback) {
+								return callback()
+							}
+						})
+					} else {
+						res.oldInternalRender(name, data, callback)
+					}
+				})
+			}
+			next()
+		}
+		catch (e) {
+			log.error(e)
+		}
+	}
+
+	webhandle.routers.preParmParse.use(changeResponseForTripartite)
+
+}