ventojs 0.10.2 → 0.12.0

package/esm/deps.d.ts

@@ -1,2 +1,6 @@
-export * as path from "./deps/deno.land/std@0.210.0/path/mod.js";
-export * as html from "./deps/deno.land/std@0.210.0/html/mod.js";
+export * as path from "./deps/deno.land/std@0.219.1/path/mod.js";
+export * as html from "./deps/deno.land/std@0.219.1/html/mod.js";
+export * as astring from "./deps/deno.land/x/astring@v1.8.6/src/astring.js";
+export * as meriyah from "meriyah";
+export * as walker from "estree-walker";
+export type * as ESTree from "estree";

package/esm/deps.js

@@ -1,2 +1,5 @@
-export * as path from "./deps/deno.land/std@0.210.0/path/mod.js";
-export * as html from "./deps/deno.land/std@0.210.0/html/mod.js";
+export * as path from "./deps/deno.land/std@0.219.1/path/mod.js";
+export * as html from "./deps/deno.land/std@0.219.1/html/mod.js";
+export * as astring from "./deps/deno.land/x/astring@v1.8.6/src/astring.js";
+export * as meriyah from "meriyah";
+export * as walker from "estree-walker";

package/esm/mod.d.ts

@@ -2,6 +2,7 @@ import { Environment } from "./src/environment.js";
 import { Loader } from "./src/loader.js";
 export interface Options {
     includes?: string | Loader;
+    /** @deprecated */
     useWith?: boolean;
     dataVarname?: string;
     autoescape?: boolean;

package/esm/mod.js

@@ -13,6 +13,7 @@ import exportTag from "./plugins/export.js";
 import echoTag from "./plugins/echo.js";
 import escape from "./plugins/escape.js";
 import unescape from "./plugins/unescape.js";
+import trim from "./plugins/trim.js";
 export default function (options = {}) {
     const loader = typeof options.includes === "object"
         ? options.includes
@@ -36,5 +37,6 @@ export default function (options = {}) {
     env.use(echoTag());
     env.use(escape());
     env.use(unescape());
+    env.use(trim());
     return env;
 }

package/esm/plugins/auto_trim.d.ts

@@ -0,0 +1,8 @@
+import type { Token } from "../src/tokenizer.js";
+import type { Environment } from "../src/environment.js";
+export declare const defaultTags: string[];
+export type AutoTrimOptions = {
+    tags: string[];
+};
+export default function (options?: AutoTrimOptions): (env: Environment) => void;
+export declare function autoTrim(tokens: Token[], options: AutoTrimOptions): void;

package/esm/plugins/auto_trim.js

@@ -0,0 +1,36 @@
+export const defaultTags = [
+    ">",
+    "#",
+    "set",
+    "/set",
+    "if",
+    "/if",
+    "else",
+    "for",
+    "/for",
+    "function",
+    "async",
+    "/function",
+    "export",
+    "/export",
+    "import",
+];
+export default function (options = { tags: defaultTags }) {
+    return (env) => {
+        env.tokenPreprocessors.push((_, tokens) => autoTrim(tokens, options));
+    };
+}
+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.startsWith(tag))) {
+            // Remove leading horizontal space
+            previous[1] = previous[1].replace(/[ \t]*$/, "");
+            // Remove trailing horizontal space + newline
+            next[1] = next[1].replace(/^[ \t]*(?:\r\n|\n)/, "");
+        }
+    }
+}

package/esm/plugins/escape.js

@@ -1,6 +1,7 @@
 import { html } from "../deps.js";
 export default function () {
     return (env) => {
-        env.filters.escape = html.escape;
+        // deno-lint-ignore no-explicit-any
+        env.filters.escape = (value) => value ? html.escape(value.toString()) : "";
     };
 }

package/esm/plugins/trim.d.ts

@@ -0,0 +1,4 @@
+import type { Token } from "../src/tokenizer.js";
+import type { Environment } from "../src/environment.js";
+export default function (): (env: Environment) => void;
+export declare function trim(_: Environment, tokens: Token[]): void;

package/esm/plugins/trim.js

@@ -0,0 +1,28 @@
+export default function () {
+    return (env) => {
+        env.tokenPreprocessors.push(trim);
+    };
+}
+export function trim(_, tokens) {
+    for (let i = 0; i < tokens.length; i++) {
+        const previous = tokens[i - 1];
+        const token = tokens[i];
+        const next = tokens[i + 1];
+        let [type, code] = token;
+        if (type === "tag" && code.startsWith("-")) {
+            previous[1] = previous[1].trimEnd();
+            code = code.slice(1);
+        }
+        if (type === "tag" && code.endsWith("-")) {
+            next[1] = next[1].trimStart();
+            code = code.slice(0, -1);
+        }
+        // Trim tag and filter code
+        switch (type) {
+            case "tag":
+            case "filter":
+                token[1] = code.trim();
+                break;
+        }
+    }
+}

package/esm/plugins/unescape.js

@@ -1,6 +1,7 @@
 import { html } from "../deps.js";
 export default function () {
     return (env) => {
-        env.filters.unescape = html.unescape;
+        // deno-lint-ignore no-explicit-any
+        env.filters.unescape = (value) => value ? html.unescape(value.toString()) : "";
     };
 }

package/esm/src/environment.d.ts

@@ -16,6 +16,7 @@ export interface TemplateSync {
     code: string;
     file?: string;
 }
+export type TokenPreprocessor = (env: Environment, tokens: Token[], path?: string) => Token[] | void;
 export type Tag = (env: Environment, code: string, output: string, tokens: Token[]) => string | undefined;
 export type FilterThis = {
     data: Record<string, unknown>;
@@ -33,6 +34,7 @@ export declare class Environment {
     cache: Map<string, Template>;
     options: Options;
     tags: Tag[];
+    tokenPreprocessors: TokenPreprocessor[];
     filters: Record<string, Filter>;
     utils: Record<string, unknown>;
     constructor(options: Options);
@@ -42,6 +44,7 @@ export declare class Environment {
     runStringSync(source: string, data?: Record<string, unknown>): TemplateResult;
     compile(source: string, path?: string, defaults?: Record<string, unknown>, sync?: false): Template;
     compile(source: string, path?: string, defaults?: Record<string, unknown>, sync?: true): TemplateSync;
+    tokenize(source: string, path?: string): Token[];
     load(file: string, from?: string): Promise<Template>;
     compileTokens(tokens: Token[], outputVar?: string, stopAt?: string[]): string[];
     compileFilters(tokens: Token[], output: string, autoescape?: boolean): string;

package/esm/src/environment.js

@@ -1,9 +1,11 @@
 import * as dntShim from "../_dnt.shims.js";
 import tokenize from "./tokenizer.js";
+import { transformTemplateCode } from "./transformer.js";
 export class Environment {
     cache = new Map();
     options;
     tags = [];
+    tokenPreprocessors = [];
     filters = {};
     utils = {};
     constructor(options) {
@@ -34,18 +36,18 @@ export class Environment {
         return template(data);
     }
     compile(source, path, defaults, sync = false) {
-        const { tokens, position, error } = tokenize(source);
-        if (error) {
-            throw this.createError(path || "unknown", source, position, error);
-        }
-        const code = this.compileTokens(tokens).join("\n");
+        const tokens = this.tokenize(source, path);
+        let code = this.compileTokens(tokens).join("\n");
         const { dataVarname, useWith } = this.options;
+        if (useWith) {
+            code = transformTemplateCode(code, dataVarname);
+        }
         const constructor = new Function("__file", "__env", "__defaults", `return${sync ? "" : " async"} function (${dataVarname}) {
         let __pos = 0;
         try {
           ${dataVarname} = Object.assign({}, __defaults, ${dataVarname});
           const __exports = { content: "" };
-          ${useWith ? `with (${dataVarname}) {${code}}` : code}
+          ${code}
           return __exports;
         } catch (cause) {
           const template = __env.cache.get(__file);
@@ -59,10 +61,29 @@ export class Environment {
         template.source = source;
         return template;
     }
+    tokenize(source, path) {
+        const result = tokenize(source);
+        let { tokens } = result;
+        const { position, error } = result;
+        if (error) {
+            throw this.createError(path || "unknown", source, position, error);
+        }
+        for (const tokenPreprocessor of this.tokenPreprocessors) {
+            const result = tokenPreprocessor(this, tokens, path);
+            if (result !== undefined) {
+                tokens = result;
+            }
+        }
+        return tokens;
+    }
     async load(file, from) {
         const path = from ? this.options.loader.resolve(from, file) : file;
         if (!this.cache.has(path)) {
-            const { source, data } = await this.options.loader.load(path);
+            // Remove query and hash params from path before loading
+            const cleanPath = path
+                .split("?")[0]
+                .split("#")[0];
+            const { source, data } = await this.options.loader.load(cleanPath);
             const template = this.compile(source, path, data);
             this.cache.set(path, template);
         }

package/esm/src/tokenizer.js

@@ -1,20 +1,13 @@
 export default function tokenize(source) {
     const tokens = [];
     let type = "string";
-    let trimNext = false;
     let position = 0;
     try {
         while (source.length > 0) {
             if (type === "string") {
                 const index = source.indexOf("{{");
                 const code = index === -1 ? source : source.slice(0, index);
-                if (trimNext) {
-                    tokens.push([type, code.trimStart(), position]);
-                    trimNext = false;
-                }
-                else {
-                    tokens.push([type, code, position]);
-                }
+                tokens.push([type, code, position]);
                 if (index === -1) {
                     break;
                 }
@@ -41,39 +34,23 @@ export default function tokenize(source) {
                 const lastIndex = indexes.length - 1;
                 let tag;
                 indexes.reduce((prev, curr, index) => {
-                    let code = source.slice(prev, curr - 2);
+                    const code = source.slice(prev, curr - 2);
                     // Tag
                     if (index === 1) {
-                        // Left trim
-                        if (code.startsWith("-")) {
-                            code = code.slice(1);
-                            const lastToken = tokens[tokens.length - 1];
-                            lastToken[1] = lastToken[1].trimEnd();
-                        }
-                        // Right trim
-                        if (code.endsWith("-") && index === lastIndex) {
-                            code = code.slice(0, -1);
-                            trimNext = true;
-                        }
-                        tag = [type, code.trim(), position];
+                        tag = [type, code, position];
                         tokens.push(tag);
                         return curr;
                     }
-                    // Right trim
-                    if (index === lastIndex && code.endsWith("-")) {
-                        code = code.slice(0, -1);
-                        trimNext = true;
-                    }
                     // Filters
-                    tokens.push(["filter", code.trim()]);
+                    tokens.push(["filter", code]);
                     return curr;
                 });
                 position += indexes[lastIndex];
                 source = source.slice(indexes[lastIndex]);
                 type = "string";
                 // Search the closing echo tag {{ /echo }}
-                if (tag?.[1] === "echo") {
-                    const end = source.match(/{{\s*\/echo\s*}}/);
+                if (tag?.[1].match(/^\-?\s*echo\s*\-?$/)) {
+                    const end = source.match(/{{\-?\s*\/echo\s*\-?}}/);
                     if (!end) {
                         throw new Error("Unclosed echo tag");
                     }

package/esm/src/transformer.d.ts

@@ -0,0 +1 @@
+export declare function transformTemplateCode(code: string, templateState: string): string;

package/esm/src/transformer.js

@@ -0,0 +1,180 @@
+import * as dntShim from "../_dnt.shims.js";
+import { astring, meriyah, walker } from "../deps.js";
+// List of identifiers that are in globalThis
+// but should be accessed as templateState.identifier
+const INCLUDE_GLOBAL = [
+    "name",
+];
+// List of identifiers that should be ignored
+// when transforming the code
+const DEFAULT_EXCLUDES = [
+    "globalThis",
+    "self",
+    "global",
+    "this",
+    "undefined",
+    "null",
+];
+// Tracks the scope of the code
+// and the variables that should be ignored
+class ScopeTracker {
+    scopes = [];
+    // The index of the global/function scope
+    globalScope = 0;
+    includes(val) {
+        for (let i = this.scopes.length - 1; i >= 0; i--) {
+            if (this.scopes[i].stack.includes(val)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    pushScope(global) {
+        if (global) {
+            this.globalScope = this.scopes.length;
+        }
+        const newScope = {
+            globalScope: this.globalScope,
+            stack: [],
+        };
+        this.scopes.push(newScope);
+    }
+    popScope() {
+        this.globalScope = this.scopes[this.scopes.length - 1].globalScope;
+        this.scopes.pop();
+    }
+    pushBinding(val, global) {
+        if (this.scopes.length === 0) {
+            this.scopes.push({ globalScope: this.globalScope, stack: [] });
+        }
+        if (global) {
+            this.scopes[this.globalScope].stack.push(val);
+        }
+        else {
+            this.scopes[this.scopes.length - 1].stack.push(val);
+        }
+    }
+    pushPatternBinding(pattern, global) {
+        switch (pattern.type) {
+            case "Identifier":
+                this.pushBinding(pattern.name, global);
+                break;
+            case "RestElement":
+                this.pushPatternBinding(pattern.argument, global);
+                break;
+            case "ArrayPattern":
+                for (const element of pattern.elements) {
+                    if (element) {
+                        this.pushPatternBinding(element, global);
+                    }
+                }
+                break;
+            case "ObjectPattern":
+                for (const prop of pattern.properties) {
+                    if (prop.type === "RestElement") {
+                        this.pushPatternBinding(prop.argument, global);
+                    }
+                    else {
+                        this.pushPatternBinding(prop.value, global);
+                    }
+                }
+                break;
+            case "AssignmentPattern":
+                this.pushPatternBinding(pattern.left, global);
+                break;
+        }
+    }
+    pushPatternBindings(patterns, global) {
+        for (const pattern of patterns) {
+            this.pushPatternBinding(pattern, global);
+        }
+    }
+}
+export function transformTemplateCode(code, templateState) {
+    const parsed = meriyah.parseScript(code, { module: true });
+    const tracker = new ScopeTracker();
+    const exclude = [
+        templateState,
+        ...DEFAULT_EXCLUDES,
+    ];
+    if (parsed.type !== "Program") {
+        throw new Error("Expected a program");
+    }
+    if (parsed.body.length === 0) {
+        throw new Error("Empty program");
+    }
+    // Transforms an identifier to a MemberExpression
+    // if it's not in the exclude list
+    //
+    // Example:
+    // Transforms {{ name }} to {{ id.name }}
+    function transformIdentifier(id) {
+        if ((!INCLUDE_GLOBAL.includes(id.name) &&
+            dntShim.dntGlobalThis[id.name] !== undefined) ||
+            exclude.includes(id.name) ||
+            tracker.includes(id.name) ||
+            id.name.startsWith("__")) {
+            return id;
+        }
+        return {
+            type: "MemberExpression",
+            object: {
+                type: "Identifier",
+                name: templateState,
+            },
+            optional: false,
+            computed: false,
+            property: id,
+        };
+    }
+    walker.walk(parsed, {
+        enter(node) {
+            switch (node.type) {
+                // Track variable declarations
+                case "VariableDeclaration":
+                    // "var" declarations are scoped to the function/global scope.
+                    tracker.pushPatternBindings(node.declarations.map((d) => d.id), node.kind === "var");
+                    break;
+                // Track function declarations, and
+                // function parameters.
+                // Also track the scope.
+                case "FunctionDeclaration":
+                case "FunctionExpression":
+                    if (node.id) {
+                        tracker.pushBinding(node.id.name);
+                    }
+                    tracker.pushScope(true);
+                    tracker.pushPatternBindings(node.params);
+                    break;
+                case "ArrowFunctionExpression":
+                    tracker.pushScope();
+                    tracker.pushPatternBindings(node.params);
+                    break;
+            }
+        },
+        leave(node, parent) {
+            switch (node.type) {
+                // Pop the scope when leaving a function
+                case "FunctionDeclaration":
+                case "FunctionExpression":
+                case "ArrowFunctionExpression":
+                    tracker.popScope();
+                    break;
+                case "Identifier":
+                    // Don't transform identifiers that aren't at the start of a MemberExpression
+                    // ie. don't transform `bar` or `baz` in `foo.bar.baz`
+                    if (parent?.type === "MemberExpression" && parent.property === node) {
+                        return;
+                    }
+                    // Don't transform identifiers that are keys in an object
+                    if (parent?.type === "Property" && parent.key === node) {
+                        return;
+                    }
+                    this.replace(transformIdentifier(node));
+                    break;
+            }
+        },
+    });
+    const generated = astring.generate(parsed);
+    return generated;
+}

package/package.json

@@ -1,27 +1,40 @@
 {
   "module": "./esm/mod.js",
-  "main": "./script/mod.js",
   "name": "ventojs",
-  "version": "0.10.2",
+  "version": "0.12.0",
   "description": "🌬 A minimal but powerful template engine",
   "license": "MIT",
   "repository": "github:oscarotero/vento",
   "homepage": "https://vento.js.org/",
   "bugs": "https://github.com/oscarotero/vento/issues",
+  "devDependencies": {
+    "@types/node": "^18.11.9",
+    "picocolors": "^1.0.0",
+    "@types/estree": "1.0.5"
+  },
   "exports": {
     ".": {
-      "import": "./esm/mod.js",
-      "require": "./script/mod.js"
+      "import": "./esm/mod.js"
+    },
+    "./src/environment.js": {
+      "import": "./esm/src/environment.js"
+    },
+    "./src/loader.js": {
+      "import": "./esm/src/loader.js"
+    },
+    "./src/tokenizer.js": {
+      "import": "./esm/src/tokenizer.js"
+    },
+    "./plugins/auto_trim.js": {
+      "import": "./esm/plugins/auto_trim.js"
     }
   },
   "scripts": {
     "test": "node test_runner.js"
   },
   "dependencies": {
+    "estree-walker": "3.0.3",
+    "meriyah": "4.4.0",
     "@deno/shim-deno": "~0.16.1"
-  },
-  "devDependencies": {
-    "@types/node": "^18.11.9",
-    "picocolors": "^1.0.0"
   }
 }

package/esm/deps/deno.land/std@0.210.0/html/entities.d.ts

@@ -1,38 +0,0 @@
-export type EntityList = Record<string, string>;
-/**
- * Escapes text for safe interpolation into HTML text content and quoted attributes
- *
- * @example
- * ```ts
- * import { escape } from "https://deno.land/std@$STD_VERSION/html/entities.ts";
- * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
- *
- * assertEquals(escape("<>'&AA"), "&lt;&gt;&#39;&amp;AA");
- *
- * // characters that don't need to be escaped will be left alone,
- * // even if named HTML entities exist for them
- * assertEquals(escape("þð"), "þð");
- * ```
- */
-export declare function escape(str: string): string;
-export type UnescapeOptions = {
-    entityList: EntityList;
-};
-/**
- * Unescapes HTML entities in text
- *
- * @example
- * ```ts
- * import { unescape } from "https://deno.land/std@$STD_VERSION/html/entities.ts";
- * import { assertEquals } from "https://deno.land/std@$STD_VERSION/assert/assert_equals.ts";
- *
- * // default options (only handles &<>'" and numeric entities)
- * assertEquals(unescape("&lt;&gt;&apos;&amp;&#65;&#x41;"), "<>'&AA");
- * assertEquals(unescape("&thorn;&eth;"), "&thorn;&eth;");
- *
- * // using the full named entity list from the HTML spec (~47K unminified)
- * import entityList from "https://deno.land/std@$STD_VERSION/html/named_entity_list.json" assert { type: "json" };
- * assertEquals(unescape("&thorn;&eth;", { entityList }), "þð");
- * ```
- */
-export declare function unescape(str: string, options?: Partial<UnescapeOptions>): string;

package/esm/deps/deno.land/std@0.210.0/path/_common/assert_path.d.ts

@@ -1 +0,0 @@
-export declare function assertPath(path: string): void;

package/esm/deps/deno.land/std@0.210.0/path/_interface.js

@@ -1,3 +0,0 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-export {};

package/esm/deps/deno.land/std@0.210.0/path/common.d.ts

@@ -1,13 +0,0 @@
-/** Determines the common path from a set of paths, using an optional separator,
- * which defaults to the OS default separator.
- *
- * ```ts
- *       import { common } from "https://deno.land/std@$STD_VERSION/path/mod.ts";
- *       const p = common([
- *         "./deno/std/path/mod.ts",
- *         "./deno/std/fs/mod.ts",
- *       ]);
- *       console.log(p); // "./deno/std/"
- * ```
- */
-export declare function common(paths: string[], sep?: "/" | "\\"): string;

package/esm/deps/deno.land/std@0.210.0/path/glob_to_regexp.d.ts

@@ -1,61 +0,0 @@
-import type { GlobOptions } from "./_common/glob_to_reg_exp.js";
-import { OSType } from "./_os.js";
-export type GlobToRegExpOptions = GlobOptions & {
-    os?: OSType;
-};
-/** Convert a glob string to a regular expression.
- *
- * Tries to match bash glob expansion as closely as possible.
- *
- * Basic glob syntax:
- * - `*` - Matches everything without leaving the path segment.
- * - `?` - Matches any single character.
- * - `{foo,bar}` - Matches `foo` or `bar`.
- * - `[abcd]` - Matches `a`, `b`, `c` or `d`.
- * - `[a-d]` - Matches `a`, `b`, `c` or `d`.
- * - `[!abcd]` - Matches any single character besides `a`, `b`, `c` or `d`.
- * - `[[:<class>:]]` - Matches any character belonging to `<class>`.
- *     - `[[:alnum:]]` - Matches any digit or letter.
- *     - `[[:digit:]abc]` - Matches any digit, `a`, `b` or `c`.
- *     - See https://facelessuser.github.io/wcmatch/glob/#posix-character-classes
- *       for a complete list of supported character classes.
- * - `\` - Escapes the next character for an `os` other than `"windows"`.
- * - \` - Escapes the next character for `os` set to `"windows"`.
- * - `/` - Path separator.
- * - `\` - Additional path separator only for `os` set to `"windows"`.
- *
- * Extended syntax:
- * - Requires `{ extended: true }`.
- * - `?(foo|bar)` - Matches 0 or 1 instance of `{foo,bar}`.
- * - `@(foo|bar)` - Matches 1 instance of `{foo,bar}`. They behave the same.
- * - `*(foo|bar)` - Matches _n_ instances of `{foo,bar}`.
- * - `+(foo|bar)` - Matches _n > 0_ instances of `{foo,bar}`.
- * - `!(foo|bar)` - Matches anything other than `{foo,bar}`.
- * - See https://www.linuxjournal.com/content/bash-extended-globbing.
- *
- * Globstar syntax:
- * - Requires `{ globstar: true }`.
- * - `**` - Matches any number of any path segments.
- *     - Must comprise its entire path segment in the provided glob.
- * - See https://www.linuxjournal.com/content/globstar-new-bash-globbing-option.
- *
- * Note the following properties:
- * - The generated `RegExp` is anchored at both start and end.
- * - Repeating and trailing separators are tolerated. Trailing separators in the
- *   provided glob have no meaning and are discarded.
- * - Absolute globs will only match absolute paths, etc.
- * - Empty globs will match nothing.
- * - Any special glob syntax must be contained to one path segment. For example,
- *   `?(foo|bar/baz)` is invalid. The separator will take precedence and the
- *   first segment ends with an unclosed group.
- * - If a path segment ends with unclosed groups or a dangling escape prefix, a
- *   parse error has occurred. Every character for that segment is taken
- *   literally in this event.
- *
- * Limitations:
- * - A negative group like `!(foo|bar)` will wrongly be converted to a negative
- *   look-ahead followed by a wildcard. This means that `!(foo).js` will wrongly
- *   fail to match `foobar.js`, even though `foobar` is not `foo`. Effectively,
- *   `!(foo|bar)` is treated like `!(@(foo|bar)*)`. This will work correctly if
- *   the group occurs not nested at the end of the segment. */
-export declare function globToRegExp(glob: string, options?: GlobToRegExpOptions): RegExp;