Initial release

Author: donhardman

.editorconfig

@@ -0,0 +1,25 @@
+root = true
+
+[*]
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+visual_wrap = true
+max_line_length = 120
+
+[*]
+indent_style = tab
+indent_size = 2
+
+[**.yaml]
+indent_style = space
+indent_size = 2
+
+[**.yml]
+indent_style = space
+indent_size = 2
+
+[**.md]
+indent_style = space
+indent_size = 2

.gitignore

@@ -0,0 +1,2 @@
+node_modules/**
+

.npmignore

@@ -0,0 +1,3 @@
+examples/**
+.editorconfig
+

README.md

@@ -1,2 +1,159 @@
-# yate
-Yet Another Template Engine
+YATE
+======
+
+YATE is tool for using html templates as JS files with DOM rendered elements and special helper to manipulate real time data updates.
+
+## Installing
+To install YATE you have to just run npm in your project dir:
+
+```bash
+npm install yate ---save-dev
+```
+
+## Usage
+### Sample usage with bin tool
+You have test.html example template. To build it just use yate bin tool:
+
+```bash
+./bin/yate.js examples/simple.yat > templates.js
+```
+
+Now merge yate.js lib with generated template
+
+```bash
+cat ./yate.js templates.js > bundle.js
+```
+
+Well you can do same as above with one command:
+
+```bash
+./bin/yate.js examples/simple.yat -b > bundle.js
+```
+
+Finally require in browser just created the bundle.js file.
+You got yate variable defined with template pool manipulation helpers and templates variable with your template.
+
+Now just get rendered DOM and append to any element. The key of template same as file name without extension.
+
+```javascript
+var t = templates.get('simple');
+document.body.appendChild(t.dom());
+```
+
+Wanna update some parameters? Easy:
+
+```javascript
+t.update({welcome_text: 'YATE works!'});
+```
+
+Now you can see rendered test template on your screen.
+
+### Usage with webpack or whatever
+First install loader for webpack. Instruction read here: (https://www.npmjs.com/package/yate-loader).
+
+Install stuff:
+
+```bash
+npm install yate
+npm install yate-loader
+```
+
+Somewhere in your code write to render
+
+```javascript
+# First require dependencies
+var yate = require('yate');
+var simple_tpl = require('examples/simple.yat');
+
+# Make pool of templates, really only one now
+var pool = yate.pool(simple_tpl);
+
+# Fetch template and render
+var t = pool.get('simple')
+document.body.appendChild(t.dom());
+t.update({welcome_text: 'YATE works!'});
+```
+
+Build your project and enjoy!
+
+## Template markup
+You can use only simple constructs in your html template.
+
+### Variables
+Just use {{ var_name }} in attribute or inside element to make it works.
+```html
+<div title="{{ title }}">{{ body }}</div>
+```
+
+### Iteration
+When making iteration inside template YATE switching context inside iterated object. So only possible to access object variables of current iterated item.
+
+```json
+{
+    "rows": [
+        {"value": 1},
+        {"value": 2}
+    ]
+}
+```
+
+```html
+<div for="rows">
+    The value is: {{ value }}
+</div>
+```
+
+You know what will be as result? :)
+
+### Condition
+Condition switches context as iteration. Its same easy to use.
+
+```json
+{
+    "first": false,
+    "second": {
+        "value": 2
+    }
+}
+```
+
+```html
+{first}
+    <div>
+        First block wont appear here
+    </div>
+{/first}
+{second}
+    <div>
+        In context of second condition: {value}
+    </div>
+{/second}
+```
+
+## Template pool methods
+### get(template, data)
+Return template object from pool of available templates using the template key.
+
+- *template* - name of template. If your template name as mytemplate.yat it must be mytemplate (without extension).
+- *data* - optional. Pass data to render your template as object.
+
+### release(template, instance)
+It releases generate template from DOM tree
+
+- *template* - name of template.
+- *instance* - generated Node of this template.
+
+## Template object methods
+When you get template from created pool, it has several methods to manipulate it.
+
+### dom()
+The method returns generated DOM tree for current template as DocumentFragment (see document.createDocumentFragment).
+
+### update(data)
+- *data* - object to update and rerender current loaded template's DOM.
+
+### remove()
+This method removes rendered element from DOM tree.
+
+## Loaders for YATE
+Webpack: (https://www.npmjs.com/package/yate-loader).

bin/yate

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+import build from './../build.js';
+
+const args = process.argv.slice(2);
+const files = [];
+
+let asModule = false;
+let asBundle = false;
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+for (const arg of args) {
+	switch (arg) {
+		case '-m':
+		case '--module':
+			asModule = true;
+			break;
+
+		case '-b':
+		case '--bundle':
+			asBundle = true;
+			break;
+
+		default:
+			files.push(arg);
+	}
+}
+
+if (files.length > 0) {
+	if (asBundle) {
+		const scriptPath = resolve(__dirname, '..', 'yate.js');
+
+		try {
+			const content = fs.readFileSync(scriptPath, { encoding: 'utf8' });
+			console.log(content);
+		} catch (error) {
+			console.error(`Error reading file: ${error.message}`);
+			process.exit(1);
+		}
+	}
+
+	new Promise((resolve, reject) => {
+		build(files, asModule)
+			.then(result => {
+				console.log(result);
+				resolve(result);
+			})
+			.catch(error => {
+				console.error('Error during build:', error);
+				reject(error);
+			});
+	});
+} else {
+	console.log("Usage: yate file1.yat [...file2.yat] [options]");
+	console.log("       yate file1.yat -m");
+	console.log("Options:");
+	console.log("  -m, --module     build as module");
+	console.log("  -b, --bundle     generate bundle code with injected yate.js");
+	console.log("Error: No input files provided.");
+	console.log("Please provide at least one .yate file to process.");
+}
+

bin/yate.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+import build from './../build.js';
+
+const args = process.argv.slice(2);
+const files = [];
+
+let asModule = false;
+let asBundle = false;
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+for (const arg of args) {
+	switch (arg) {
+		case '-m':
+		case '--module':
+			asModule = true;
+			break;
+
+		case '-b':
+		case '--bundle':
+			asBundle = true;
+			break;
+
+		default:
+			files.push(arg);
+	}
+}
+
+if (files.length > 0) {
+	if (asBundle) {
+		const scriptPath = resolve(__dirname, '..', 'yate.js');
+
+		try {
+			const content = fs.readFileSync(scriptPath, { encoding: 'utf8' });
+			console.log(content);
+		} catch (error) {
+			console.error(`Error reading file: ${error.message}`);
+			process.exit(1);
+		}
+	}
+
+	new Promise((resolve, reject) => {
+		build(files, asModule)
+			.then(result => {
+				console.log(result);
+				resolve(result);
+			})
+			.catch(error => {
+				console.error('Error during build:', error);
+				reject(error);
+			});
+	});
+} else {
+	console.log("Usage: yate file1.yat [...file2.yat] [options]");
+	console.log("       yate file1.yat -m");
+	console.log("Options:");
+	console.log("  -m, --module     build as module");
+	console.log("  -b, --bundle     generate bundle code with injected yate.js");
+	console.log("Error: No input files provided.");
+	console.log("Please provide at least one .yat file to process.");
+}
+

build.js

@@ -0,0 +1,38 @@
+import { DOMParser } from 'xmldom';
+import Compile from './compile.js';
+import { promises as fs } from 'fs';
+
+const parser = new DOMParser();
+
+const processFiles = async (files, asModule) => {
+	const fileArray = Array.isArray(files) ? files : [files];
+
+	const pool = {};
+	await Promise.all(fileArray.map(async (file) => {
+		const content = await fs.readFile(file, 'utf8');
+		const parsed = parser.parseFromString(content);
+		const fileName = file.split('/').pop().split('.')[0];
+		await new Compile(parsed, pool).build(fileName);
+	}));
+
+	const poolCode = Object.entries(pool)
+	.map(([template, code]) => `"${template}":${code}`)
+	.join(',');
+
+	const moduleCode = `
+const yate = require("yate");
+module.exports = {${poolCode}};
+`;
+
+	const windowCode = `
+const templateList = {${poolCode}};
+window.templates = yate.pool(templateList);
+`;
+
+	return asModule ? moduleCode : windowCode;
+};
+
+export default async function (files, asModule) {
+	return processFiles(files, asModule);
+}
+