spooder 4.2.18 → 4.3.0

package/README.md

@@ -200,7 +200,9 @@ When starting or restarting a server process, `spooder` can automatically update
 {
 	"spooder": {
 		"update": [
-			"git pull",
+			"git reset --hard",
+			"git clean -fd",
+			"git pull origin main",
 			"bun install"
 		]
 	}
@@ -210,7 +212,7 @@ When starting or restarting a server process, `spooder` can automatically update
 Each command should be a separate entry in the array and will be executed in sequence. The server process will be started once all commands have resolved.
 
 > [!IMPORTANT]
-> Chainging commands using `&&` or `||` operators does not work.
+> Chaining commands using `&&` or `||` operators does not work.
 
 If a command in the sequence fails, the remaining commands will not be executed, however the server will still be started. This is preferred over entering a restart loop or failing to start the server at all.
 
@@ -435,7 +437,7 @@ In addition to the information provided by the developer, `spooder` also include
 		"modules": "108"
 	},
 	"bun": {
-		"version": "0.6.4",
+		"version": "0.6.5",
 		"rev": "f02561530fda1ee9396f51c8bc99b38716e38296",
 		"memory_usage": {
 			"rss": 99672064,
@@ -778,7 +780,7 @@ function default_directory_handler(file_path: string, file: BunFile, stat: DirSt
 ```
 
 > [!NOTE]
-> Uncaught `ENOENT` errors throw from the directory handler will return a `404` response, other errors will return a `500` response.
+> Uncaught `ENOENT` errors thrown from the directory handler will return a `404` response, other errors will return a `500` response.
 
 > [!NOTE]
 > The call to `apply_range` in the default directory handler will automatically slice the file based on the [`Range`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Range) header. This function is also exposed as part of the `spooder` API for use in your own handlers.
@@ -1064,6 +1066,24 @@ const html = parse_template(template, replacements);
 </html>
 ```
 
+Object properties are supported by using the dot syntax.
+
+```ts
+const template = `<span>{$foo.bar}</span>`;
+
+const replacements = {
+	foo: {
+		bar: 'Hello, world!';
+	}
+};
+
+const html = parse_template(template, replacements);
+```
+
+```html
+<span>Hello, world!</span>
+```
+
 By default, placeholders that do not appear in the replacement object will be left as-is. Set `drop_missing` to `true` to remove them.
 
 ```ts
@@ -1105,16 +1125,15 @@ parse_template('Hello {$world}', replacer);
 	</body>
 </html>
 ```
-
 `parse_template` supports looping arrays with the following syntax.
 
 ```html
-{$for:foo}My colour is %s{/for}
+{$for:foo as bar}My colour is {$bar}{/for}
 ```
 ```ts
 const template = `
 	<ul>
-		{$for:foo}<li>%s</li>{/for}
+		{$for:foo as bar}<li>{$bar}</li>{/for}
 	</ul>
 `;
 
@@ -1133,24 +1152,39 @@ const html = parse_template(template, replacements);
 </ul>
 ```
 
-All placeholders inside a `{$for:}` loop are substituted, but only if the loop variable exists.
-
-In the following example, `missing` does not exist, so `test` is not substituted inside the loop, but `test` is still substituted outside the loop.
+Loops also support object properties using the dot syntax.
 
 ```html
-<div>Hello {$test}!</div>
-{$for:missing}<div>Loop {$test}</div>{/for}
+{$for:foo as bar}My colour is {$bar.baz}{/for}
 ```
-
 ```ts
-parse_template(..., {
-	test: 'world'
-});
+const template = `
+	<ul>
+		{$for:foo as bar}<li>My colour is {$bar.baz}</li>{/for}
+	</ul>
+`;
+```
+
+If/else statements are supported in templates, which include blocks based on the existence/truthiness of a property.
+
+```html
+{$if:is_on_earth}
+	Hello, world!
+{else}
+	Hello, Mars!
+{/if}
 ```
 
+This also works with nested properties and loops.
+
 ```html
-<div>Hello world!</div>
-{$for}Loop <div>{$test}</div>{/for}
+{$for:countries as country}
+	{$if:country.is_in_europe}
+		Europe: {$country.name}
+	{else}
+		Not Europe: {$country.name}
+	{/if}
+{/for}
 ```
 
 <a id="api-content-generate-hash-subs"></a>

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "spooder",
 	"type": "module",
-	"version": "4.2.18",
+	"version": "4.3.0",
 	"exports": {
 		".": {
 			"bun": "./src/api.ts",

package/src/api.ts

@@ -108,8 +108,8 @@ export async function safe(target_fn: Callable) {
 	}
 }
 
-type ReplacerFn = (key: string) => string | Array<string> | undefined;
-type Replacements = Record<string, string | Array<string>> | ReplacerFn;
+type ReplacerFn = (key: string) => string | Array<any> | Record<string, any> | undefined;
+type Replacements = Record<string, string | Array<any> | Record<string, any>> | ReplacerFn;
 
 export function parse_template(template: string, replacements: Replacements, drop_missing = false): string {
 	let result = '';
@@ -118,6 +118,28 @@ export function parse_template(template: string, replacements: Replacements, dro
 
 	const is_replacer_fn = typeof replacements === 'function';
 
+	function getValue(key: string): any {
+		const var_parts = key.split('.');
+		let value: any = is_replacer_fn ? replacements(var_parts[0]) : replacements[var_parts[0]];
+		
+		for (let j = 1; j < var_parts.length; j++) {
+			if (value && typeof value === 'object') {
+				value = value[var_parts[j]];
+			} else {
+				value = undefined;
+				break;
+			}
+		}
+		return value;
+	}
+
+	function parseBlock(content: string, local_replacements: Replacements): string {
+		return parse_template(content, {
+			...replacements,
+			...local_replacements
+		}, drop_missing);
+	}
+
 	const template_length = template.length;
 	for (let i = 0; i < template_length; i++) {
 		const char = template[i];
@@ -130,9 +152,8 @@ export function parse_template(template: string, replacements: Replacements, dro
 			buffer_active = false;
 
 			if (buffer.startsWith('for:')) {
-				const loop_key = buffer.substring(4);
-
-				const loop_entries = is_replacer_fn ? replacements(loop_key) : replacements[loop_key];
+				const [loop_key, loop_var] = buffer.substring(4).split(' as ');
+				const loop_entries = getValue(loop_key);
 				const loop_content_start_index = i + 1;
 				const loop_close_index = template.indexOf('{/for}', loop_content_start_index);
 				
@@ -141,19 +162,48 @@ export function parse_template(template: string, replacements: Replacements, dro
 						result += '{$' + buffer + '}';
 				} else {
 					const loop_content = template.substring(loop_content_start_index, loop_close_index);
-					if (loop_entries !== undefined) {
-						for (const loop_entry of loop_entries) {
-							const inner_content = loop_content.replaceAll('%s', loop_entry);
-							result += parse_template(inner_content, replacements, drop_missing);
-						}
+					if (Array.isArray(loop_entries)) {
+						for (const loop_entry of loop_entries)
+							result += parseBlock(loop_content, { [loop_var]: loop_entry });
 					} else {
 						if (!drop_missing)
 							result += '{$' + buffer + '}' + loop_content + '{/for}';
 					}
-					i += loop_content.length + 6;
+					i = loop_close_index + 5; // Move past {/for}
+				}
+			} else if (buffer.startsWith('if:')) {
+				const condition_key = buffer.substring(3);
+				const condition_value = getValue(condition_key);
+				const if_content_start_index = i + 1;
+				const if_close_index = template.indexOf('{/if}', if_content_start_index);
+				
+				if (if_close_index === -1) {
+					if (!drop_missing)
+						result += '{$' + buffer + '}';
+				} else {
+					const if_content = template.substring(if_content_start_index, if_close_index);
+					const else_index = if_content.indexOf('{else}');
+					
+					if (else_index === -1) {
+						// No else block
+						if (condition_value) {
+							result += parseBlock(if_content, {});
+						}
+					} else {
+						// Has else block
+						const true_content = if_content.substring(0, else_index);
+						const false_content = if_content.substring(else_index + 6); // +6 to move past {else}
+						
+						if (condition_value)
+							result += parseBlock(true_content, {});
+						else
+							result += parseBlock(false_content, {});
+					}
+					i = if_close_index + 4; // Move past {/if}
 				}
 			} else {
-				const replacement = is_replacer_fn ? replacements(buffer) : replacements[buffer];
+				const replacement = getValue(buffer);
+
 				if (replacement !== undefined)
 					result += replacement;
 				else if (!drop_missing)