ventojs 2.1.0 → 2.2.0

package/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [2.2.0] - 2025-10-15
+### Added
+- Support for destructuring in set [#158] [#154].
+
+### Fixed
+- Possible variables naming collision [#157].
+- `auto_trim` plugin edge cases [#159].
+- `set`: allow `$` character in the variable name.
+
+## [2.1.1] - 2025-09-18
+### Fixed
+- The tag `include` fails when it's inside a `slot`.
+
 ## [2.1.0] - 2025-09-17
 ### Added
 - New `strict` mode to fail when using an undefined variable. This mode has a different performance profile than normal mode; it's mostly intended for testing and debug purposes. [#101], [#142]
@@ -80,8 +93,14 @@ Vento 2.0 is now dependency-free and compatible with browsers without a build st
 [#148]: https://github.com/ventojs/vento/issues/148
 [#150]: https://github.com/ventojs/vento/issues/150
 [#151]: https://github.com/ventojs/vento/issues/151
+[#154]: https://github.com/ventojs/vento/issues/154
 [#156]: https://github.com/ventojs/vento/issues/156
+[#157]: https://github.com/ventojs/vento/issues/157
+[#158]: https://github.com/ventojs/vento/issues/158
+[#159]: https://github.com/ventojs/vento/issues/159
 
+[2.2.0]: https://github.com/ventojs/vento/compare/v2.1.1...v2.2.0
+[2.1.1]: https://github.com/ventojs/vento/compare/v2.1.0...v2.1.1
 [2.1.0]: https://github.com/ventojs/vento/compare/v2.0.2...v2.1.0
 [2.0.2]: https://github.com/ventojs/vento/compare/v2.0.1...v2.0.2
 [2.0.1]: https://github.com/ventojs/vento/compare/v2.0.0...v2.0.1

package/core/environment.js

@@ -7,6 +7,7 @@ export class Environment {
     tags = [];
     tokenPreprocessors = [];
     filters = {};
+    #tempVariablesCreated = 0;
     utils = {
         callMethod,
         createError,
@@ -236,6 +237,12 @@ export class Environment {
         }
         return output;
     }
+    getTempVariable() {
+        const id = this.#tempVariablesCreated;
+        const variable = `__tmp${id}`;
+        this.#tempVariablesCreated++;
+        return variable;
+    }
 }
 function isGlobal(name) {
     if (name == "name")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ventojs",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "🌬 A minimal but powerful template engine",
   "type": "module",
   "repository": {

package/plugins/auto_trim.js

@@ -1,6 +1,5 @@
 export const defaultTags = [
     ">",
-    "#",
     "set",
     "/set",
     "if",
@@ -15,6 +14,8 @@ export const defaultTags = [
     "/export",
     "import",
 ];
+const LEADING_WHITESPACE = /(^|\n)[ \t]+$/;
+const TRAILING_WHITESPACE = /^[ \t]*\r?\n/;
 export default function (options = { tags: defaultTags }) {
     return (env) => {
         env.tokenPreprocessors.push((_, tokens) => autoTrim(tokens, options));
@@ -22,21 +23,34 @@ export default function (options = { tags: defaultTags }) {
 }
 export function autoTrim(tokens, options) {
     for (let i = 0; i < tokens.length; i++) {
-        const previous = tokens[i - 1];
         const token = tokens[i];
-        const next = tokens[i + 1];
         const [type, code] = token;
-        if (type === "tag" &&
-            options.tags.find((tag) => code === tag || code.startsWith(tag + " "))) {
-            // Remove leading horizontal space
-            previous[1] = previous[1].replace(/(^|\n)[ \t]*$/, "$1");
-            // Remove trailing horizontal space + newline
-            if (next) {
-                next[1] = next[1].replace(/^[ \t]*(?:\r\n|\n)/, "");
-            }
+        let needsTrim = false;
+        if (type === "comment") {
+            needsTrim = true;
+        }
+        else if (type === "tag") {
+            needsTrim = options.tags.some((tag) => {
+                if (!code.startsWith(tag))
+                    return false;
+                return /\s/.test(code[tag.length] ?? " ");
+            });
         }
-        else if (type === "comment") {
-            previous[1] = previous[1].replace(/(?:\r\n|\n)[ \t]*$/, "");
+        if (!needsTrim)
+            continue;
+        // Remove leading horizontal space
+        const previous = tokens[i - 1];
+        previous[1] = previous[1].replace(LEADING_WHITESPACE, "$1");
+        // Skip "filter" tokens to find the next "string" token
+        for (let j = i + 1; j < tokens.length; j++) {
+            if (tokens[j][0] === "filter")
+                continue;
+            if (tokens[j][0] !== "string")
+                break;
+            // Remove trailing horizontal space + newline
+            const next = tokens[j];
+            next[1] = next[1].replace(TRAILING_WHITESPACE, "");
+            break;
         }
     }
 }

package/plugins/echo.js

@@ -14,14 +14,15 @@ function echoTag(env, [, code], output, tokens) {
         return `${output} += ${compiled};`;
     }
     // Captured echo, e.g. {{ echo |> toUpperCase }} foo {{ /echo }}
-    const compiled = [`let __tmp = "";`];
-    const filters = env.compileFilters(tokens, "__tmp");
-    compiled.push(...env.compileTokens(tokens, "__tmp", "/echo"));
-    if (filters != "__tmp") {
-        compiled.push(`__tmp = ${filters}`);
+    const tmp = env.getTempVariable();
+    const compiled = [`let ${tmp} = "";`];
+    const filters = env.compileFilters(tokens, tmp);
+    compiled.push(...env.compileTokens(tokens, tmp, "/echo"));
+    if (filters != tmp) {
+        compiled.push(`${tmp} = ${filters}`);
     }
     return `{
     ${compiled.join("\n")}
-    ${output} += __tmp;
+    ${output} += ${tmp};
   }`;
 }

package/plugins/function.js

@@ -16,13 +16,14 @@ function functionTag(env, token, _output, tokens) {
     const [_, exp, as, name, args] = match;
     const compiled = [];
     compiled.push(`${as || ""} function ${name} ${args || "()"} {`);
-    compiled.push(`let __output = "";`);
-    const result = env.compileFilters(tokens, "__output");
+    const tmp = env.getTempVariable();
+    compiled.push(`let ${tmp} = "";`);
+    const result = env.compileFilters(tokens, tmp);
     if (exp) {
-        compiled.push(...env.compileTokens(tokens, "__output", "/export"));
+        compiled.push(...env.compileTokens(tokens, tmp, "/export"));
     }
     else {
-        compiled.push(...env.compileTokens(tokens, "__output", "/function"));
+        compiled.push(...env.compileTokens(tokens, tmp, "/function"));
     }
     compiled.push(`return __env.utils.safeString(${result});`);
     compiled.push(`}`);

package/plugins/import.js

@@ -21,10 +21,11 @@ function importTag(env, token) {
     const variables = [];
     const [, identifiers, specifier] = match;
     const defaultImport = identifiers.match(DEFAULT_IMPORT);
+    const tmp = env.getTempVariable();
     if (defaultImport) {
         const [name] = defaultImport;
         variables.push(name);
-        compiled.push(`${name} = __tmp;`);
+        compiled.push(`${name} = ${tmp};`);
     }
     else {
         const namedImports = identifiers.match(NAMED_IMPORTS);
@@ -46,7 +47,7 @@ function importTag(env, token) {
                     throw new SourceError("Invalid named import", position);
                 }
             });
-            compiled.push(`({${chunks.join(",")}} = __tmp);`);
+            compiled.push(`({${chunks.join(",")}} = ${tmp});`);
         }
         else {
             throw new SourceError("Invalid import tag", position);
@@ -54,7 +55,7 @@ function importTag(env, token) {
     }
     const { dataVarname } = env.options;
     return `let ${variables.join(",")}; {
-    let __tmp = await __env.run(${specifier}, {...${dataVarname}}, __template.path, ${position});
+    let ${tmp} = await __env.run(${specifier}, {...${dataVarname}}, __template.path, ${position});
     ${compiled.join("\n")}
   }`;
 }

package/plugins/include.js

@@ -27,12 +27,13 @@ function includeTag(env, token, output, tokens) {
         data = tagCode.slice(bracketIndex).trim();
     }
     const { dataVarname } = env.options;
+    const tmp = env.getTempVariable();
     return `{
-    const __tmp = await __env.run(${file},
+    const ${tmp} = await __env.run(${file},
       {...${dataVarname}${data ? `, ...${data}` : ""}},
       __template.path,
       ${position}
     );
-    ${output} += ${env.compileFilters(tokens, "__tmp.content")};
+    ${output} += ${env.compileFilters(tokens, `${tmp}.content`)};
   }`;
 }

package/plugins/layout.js

@@ -39,10 +39,11 @@ function slotTag(env, token, _output, tokens) {
     if (!SLOT_NAME.test(name)) {
         throw new SourceError(`Invalid slot name "${name}"`, position);
     }
-    const compiledFilters = env.compileFilters(tokens, "__tmp");
+    const tmp = env.getTempVariable();
+    const compiledFilters = env.compileFilters(tokens, tmp);
     return `{
-    let __tmp = '';
-    ${env.compileTokens(tokens, "__tmp", "/slot").join("\n")}
+    let ${tmp} = '';
+    ${env.compileTokens(tokens, tmp, "/slot").join("\n")}
     __slots.${name} ??= '';
     __slots.${name} += ${compiledFilters};
     __slots.${name} = __env.utils.safeString(__slots.${name});

package/plugins/set.js

@@ -4,6 +4,9 @@ export default function () {
         env.tags.push(setTag);
     };
 }
+const VARNAME = /^[a-zA-Z_$][\w$]*$/;
+const DETECTED_VARS = /([a-zA-Z_$][\w$]*)\b(?!\s*\:)/g;
+const VALID_TAG = /^set\s+([\w{}[\]\s,:.$]+)\s*=\s*([\s\S]+)$/;
 function setTag(env, token, _output, tokens) {
     const [, code, position] = token;
     if (!code.startsWith("set ")) {
@@ -13,12 +16,25 @@ function setTag(env, token, _output, tokens) {
     const { dataVarname } = env.options;
     // Value is set (e.g. {{ set foo = "bar" }})
     if (expression.includes("=")) {
-        const match = code.match(/^set\s+([\w]+)\s*=\s*([\s\S]+)$/);
+        const match = code.match(VALID_TAG);
         if (!match) {
             throw new SourceError("Invalid set tag", position);
         }
-        const [, variable, value] = match;
+        const variable = match[1].trim();
+        const value = match[2].trim();
         const val = env.compileFilters(tokens, value);
+        if ((variable.startsWith("{") && variable.endsWith("}")) ||
+            (variable.startsWith("[") && variable.endsWith("]"))) {
+            const names = Array.from(variable.matchAll(DETECTED_VARS))
+                .map((n) => n[1]);
+            return `
+        var ${variable} = ${val};
+        Object.assign(${dataVarname}, { ${names.join(", ")} });
+      `;
+        }
+        if (!VARNAME.test(variable)) {
+            throw new SourceError("Invalid variable name", position);
+        }
         return `var ${variable} = ${dataVarname}["${variable}"] = ${val};`;
     }
     // Value is captured (eg: {{ set foo }}bar{{ /set }})

package/types/core/environment.d.ts

@@ -37,6 +37,7 @@ export interface Options {
     strict: boolean;
 }
 export declare class Environment {
+    #private;
     cache: Map<string, Template | Promise<Template>>;
     options: Options;
     tags: Tag[];
@@ -52,6 +53,7 @@ export declare class Environment {
     load(file: string, from?: string, position?: number): Promise<Template>;
     compileTokens(tokens: Token[], outputVar?: string, closeToken?: string, closeTokenOptional?: boolean): string[];
     compileFilters(tokens: Token[], output: string, autoescape?: boolean): string;
+    getTempVariable(): string;
 }
 export declare class SafeString extends String {
 }