ventojs 1.14.0 → 2.0.0-canary.0

package/package.json

@@ -1,41 +1,179 @@
 {
   "name": "ventojs",
-  "version": "1.14.0",
+  "version": "2.0.0-canary.0",
   "description": "🌬 A minimal but powerful template engine",
-  "homepage": "https://vento.js.org/",
-  "repository": "github:oscarotero/vento",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ventojs/vento.git"
+  },
+  "keywords": [
+    "template engine"
+  ],
+  "author": "Óscar Otero",
   "license": "MIT",
-  "bugs": "https://github.com/oscarotero/vento/issues",
-  "module": "./esm/mod.js",
+  "bugs": {
+    "url": "https://github.com/ventojs/vento/issues"
+  },
+  "homepage": "https://vento.js.org/",
   "exports": {
     ".": {
-      "import": "./esm/mod.js"
+      "import": {
+        "types": "./types/mod.d.ts",
+        "default": "./mod.js"
+      }
+    },
+    "./browser.js": {
+      "import": {
+        "types": "./types/browser.d.ts",
+        "default": "./browser.js"
+      }
+    },
+    "./core/environment.js": {
+      "import": {
+        "types": "./types/core/environment.d.ts",
+        "default": "./core/environment.js"
+      }
+    },
+    "./core/errors.js": {
+      "import": {
+        "types": "./types/core/errors.d.ts",
+        "default": "./core/errors.js"
+      }
+    },
+    "./core/js.js": {
+      "import": {
+        "types": "./types/core/js.d.ts",
+        "default": "./core/js.js"
+      }
     },
-    "./src/environment.js": {
-      "import": "./esm/src/environment.js"
+    "./core/reserved.js": {
+      "import": {
+        "types": "./types/core/reserved.d.ts",
+        "default": "./core/reserved.js"
+      }
     },
-    "./src/loader.js": {
-      "import": "./esm/src/loader.node.js"
+    "./core/tokenizer.js": {
+      "import": {
+        "types": "./types/core/tokenizer.d.ts",
+        "default": "./core/tokenizer.js"
+      }
     },
-    "./src/tokenizer.js": {
-      "import": "./esm/src/tokenizer.js"
+    "./highlightjs-vento.js": "./highlightjs-vento.js",
+    "./loaders/file.js": {
+      "import": {
+        "types": "./types/loaders/file.d.ts",
+        "default": "./loaders/file.js"
+      }
+    },
+    "./loaders/memory.js": {
+      "import": {
+        "types": "./types/loaders/memory.d.ts",
+        "default": "./loaders/memory.js"
+      }
+    },
+    "./loaders/url.js": {
+      "import": {
+        "types": "./types/loaders/url.d.ts",
+        "default": "./loaders/url.js"
+      }
+    },
+    "./mod.js": {
+      "import": {
+        "types": "./types/mod.d.ts",
+        "default": "./mod.js"
+      }
     },
     "./plugins/auto_trim.js": {
-      "import": "./esm/plugins/auto_trim.js"
-    }
-  },
-  "scripts": {
-    "test": "node test_runner.js"
-  },
-  "dependencies": {
-    "estree-walker": "3.0.3",
-    "meriyah": "6.0.5"
-  },
-  "devDependencies": {
-    "@types/node": "^20.9.0",
-    "picocolors": "^1.0.0",
-    "@deno/shim-deno": "~0.18.0",
-    "@types/estree": "1.0.5"
-  },
-  "_generatedBy": "dnt@dev"
+      "import": {
+        "types": "./types/plugins/auto_trim.d.ts",
+        "default": "./plugins/auto_trim.js"
+      }
+    },
+    "./plugins/echo.js": {
+      "import": {
+        "types": "./types/plugins/echo.d.ts",
+        "default": "./plugins/echo.js"
+      }
+    },
+    "./plugins/escape.js": {
+      "import": {
+        "types": "./types/plugins/escape.d.ts",
+        "default": "./plugins/escape.js"
+      }
+    },
+    "./plugins/export.js": {
+      "import": {
+        "types": "./types/plugins/export.d.ts",
+        "default": "./plugins/export.js"
+      }
+    },
+    "./plugins/for.js": {
+      "import": {
+        "types": "./types/plugins/for.d.ts",
+        "default": "./plugins/for.js"
+      }
+    },
+    "./plugins/function.js": {
+      "import": {
+        "types": "./types/plugins/function.d.ts",
+        "default": "./plugins/function.js"
+      }
+    },
+    "./plugins/if.js": {
+      "import": {
+        "types": "./types/plugins/if.d.ts",
+        "default": "./plugins/if.js"
+      }
+    },
+    "./plugins/import.js": {
+      "import": {
+        "types": "./types/plugins/import.d.ts",
+        "default": "./plugins/import.js"
+      }
+    },
+    "./plugins/include.js": {
+      "import": {
+        "types": "./types/plugins/include.d.ts",
+        "default": "./plugins/include.js"
+      }
+    },
+    "./plugins/js.js": {
+      "import": {
+        "types": "./types/plugins/js.d.ts",
+        "default": "./plugins/js.js"
+      }
+    },
+    "./plugins/layout.js": {
+      "import": {
+        "types": "./types/plugins/layout.d.ts",
+        "default": "./plugins/layout.js"
+      }
+    },
+    "./plugins/mod.js": {
+      "import": {
+        "types": "./types/plugins/mod.d.ts",
+        "default": "./plugins/mod.js"
+      }
+    },
+    "./plugins/set.js": {
+      "import": {
+        "types": "./types/plugins/set.d.ts",
+        "default": "./plugins/set.js"
+      }
+    },
+    "./plugins/trim.js": {
+      "import": {
+        "types": "./types/plugins/trim.d.ts",
+        "default": "./plugins/trim.js"
+      }
+    },
+    "./plugins/unescape.js": {
+      "import": {
+        "types": "./types/plugins/unescape.d.ts",
+        "default": "./plugins/unescape.js"
+      }
+    },
+    "./prism-vento.js": "./prism-vento.js"
+  }
 }

package/{esm/plugins → plugins}/auto_trim.js

@@ -1,4 +1,3 @@
-import "../_dnt.polyfills.js";
 export const defaultTags = [
     ">",
     "#",

package/plugins/echo.js

@@ -0,0 +1,31 @@
+export default function () {
+    return (env) => {
+        env.tags.push(echoTag);
+    };
+}
+function echoTag(env, code, output, tokens) {
+    if (!/^echo\b/.test(code)) {
+        return;
+    }
+    const inline = code.slice(4).trim();
+    // Inline value, e.g. {{ echo "foo" |> toUpperCase() }}
+    if (inline) {
+        const compiled = env.compileFilters(tokens, inline, env.options.autoescape);
+        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 closeToken = tokens.shift();
+    if (!closeToken || closeToken[0] != "tag" || closeToken[1] != "/echo") {
+        throw new Error("Unclosed echo tag");
+    }
+    return `{
+    ${compiled.join("\n")}
+    ${output} += __tmp;
+  }`;
+}

package/plugins/escape.js

@@ -0,0 +1,17 @@
+const UNSAFE = /['"&<>]/g;
+const escapeMap = {
+    "'": "&apos;",
+    '"': "&quot;",
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+};
+export default function () {
+    return (env) => {
+        env.filters.escape = (value) => {
+            if (!value)
+                return "";
+            return value.toString().replace(UNSAFE, (match) => escapeMap[match]);
+        };
+    };
+}

package/plugins/export.js

@@ -0,0 +1,68 @@
+export default function () {
+    return (env) => {
+        env.tags.push(exportTag);
+    };
+}
+const EXPORT_START = /^export\b\s*/;
+const BLOCK_EXPORT = /^([a-zA-Z_]\w*)\s*$/;
+const INLINE_NAMED_EXPORT = /^([a-zA-Z_]\w*)\s*=([^]*)$/;
+const NAMED_EXPORTS = /^{[^]*?}$/;
+const AS = /\s+\bas\b\s+/;
+function exportTag(env, code, _output, tokens) {
+    const exportStart = code.match(EXPORT_START);
+    if (!exportStart) {
+        return;
+    }
+    const source = code.slice(exportStart[0].length);
+    const compiled = [];
+    const { dataVarname } = env.options;
+    // {{ export foo }}content{{ /export }}
+    const blockExport = source.match(BLOCK_EXPORT);
+    if (blockExport) {
+        const [, name] = blockExport;
+        const compiledFilters = env.compileFilters(tokens, name);
+        compiled.push(`var ${name} = "";`);
+        compiled.push(...env.compileTokens(tokens, name, ["/export"]));
+        if (tokens[0]?.[0] !== "tag" || tokens[0]?.[1] !== "/export") {
+            throw new Error(`Missing closing tag for export tag: ${code}`);
+        }
+        tokens.shift();
+        compiled.push(`${name} = ${compiledFilters}`);
+        compiled.push(`${dataVarname}["${name}"] = ${name};`);
+        compiled.push(`__exports["${name}"] = ${name};`);
+        return compiled.join("\n");
+    }
+    // {{ export foo = "content" }}
+    const inlineNamedExport = source.match(INLINE_NAMED_EXPORT);
+    if (inlineNamedExport) {
+        const [, name, content] = inlineNamedExport;
+        compiled.push(`var ${name} = "";`);
+        compiled.push(`${name} = ${env.compileFilters(tokens, content)};`);
+        compiled.push(`${dataVarname}["${name}"] = ${name};`);
+        compiled.push(`__exports["${name}"] = ${name};`);
+        return compiled.join("\n");
+    }
+    // {{ export { foo, bar as baz } }}
+    const namedExports = source.match(NAMED_EXPORTS);
+    if (namedExports) {
+        const [full] = namedExports;
+        const chunks = full.slice(1, -1).split(",");
+        for (const chunk of chunks) {
+            const names = chunk.trim().split(AS);
+            if (names.length == 1) {
+                const [name] = names;
+                const value = `${dataVarname}["${name}"] ?? ${name}`;
+                compiled.push(`__exports["${name}"] = ${value};`);
+            }
+            else if (names.length == 2) {
+                const [name, rename] = names;
+                const value = `${dataVarname}["${name}"] ?? ${name}`;
+                compiled.push(`__exports["${rename}"] = ${value};`);
+            }
+            else {
+                throw new Error(`Invalid export: ${code}`);
+            }
+        }
+        return compiled.join("\n");
+    }
+}

package/{esm/plugins → plugins}/for.js

@@ -1,4 +1,4 @@
-import analyze from "../src/js.js";
+import iterateTopLevel from "../core/js.js";
 export default function () {
     return (env) => {
         env.tags.push(forTag);
@@ -109,15 +109,11 @@ async function* asyncIterableToEntries(iterator) {
     }
 }
 function getDestructureContent(code) {
-    let index = 0;
-    analyze(code, (type, i) => {
-        if (type === "close") {
-            index = i;
-            return false;
-        }
-    });
+    const generator = iterateTopLevel(code);
+    generator.next();
+    const [position] = generator.next().value;
     return [
-        code.slice(0, index).trim(),
-        code.slice(index + 1).trim(),
+        code.slice(0, position + 1).trim(),
+        code.slice(position + 1).trim(),
     ];
 }

package/plugins/import.js

@@ -0,0 +1,58 @@
+export default function () {
+    return (env) => {
+        env.tags.push(importTag);
+    };
+}
+const IMPORT_STATEMENT = /^import\b\s*([^]*?)\s*\bfrom\b([^]*)$/;
+const DEFAULT_IMPORT = /^\b[a-zA-Z_]\w*\b$/i;
+const NAMED_IMPORTS = /^{[^]*?}$/;
+const AS = /\s+\bas\b\s+/;
+function importTag(env, code) {
+    if (!code.startsWith("import ")) {
+        return;
+    }
+    const match = code.match(IMPORT_STATEMENT);
+    if (!match) {
+        throw new Error(`Invalid import: ${code}`);
+    }
+    const compiled = [];
+    const variables = [];
+    const [, identifiers, specifier] = match;
+    const defaultImport = identifiers.match(DEFAULT_IMPORT);
+    if (defaultImport) {
+        const [name] = defaultImport;
+        variables.push(name);
+        compiled.push(`${name} = __tmp;`);
+    }
+    else {
+        const namedImports = identifiers.match(NAMED_IMPORTS);
+        if (namedImports) {
+            const [full] = namedImports;
+            const chunks = full.slice(1, -1).split(",").map((chunk) => {
+                const names = chunk.trim().split(AS);
+                if (names.length == 1) {
+                    const [name] = names;
+                    variables.push(name);
+                    return name;
+                }
+                else if (names.length == 2) {
+                    const [name, rename] = names;
+                    variables.push(rename);
+                    return `${name}: ${rename}`;
+                }
+                else {
+                    throw new Error(`Invalid import: ${code}`);
+                }
+            });
+            compiled.push(`({${chunks.join(",")}} = __tmp);`);
+        }
+        else {
+            throw new Error(`Invalid import: ${code}`);
+        }
+    }
+    const { dataVarname } = env.options;
+    return `let ${variables.join(",")}; {
+    let __tmp = await __env.run(${specifier}, {...${dataVarname}}, __file);
+    ${compiled.join("\n")}
+  }`;
+}

package/plugins/include.js

@@ -0,0 +1,35 @@
+import iterateTopLevel from "../core/js.js";
+export default function () {
+    return (env) => {
+        env.tags.push(includeTag);
+    };
+}
+function includeTag(env, code, output, tokens) {
+    if (!code.startsWith("include ")) {
+        return;
+    }
+    const tagCode = code.substring(7).trim();
+    let file = tagCode;
+    let data = "";
+    // includes { data }
+    if (tagCode.endsWith("}")) {
+        let bracketIndex = -1;
+        for (const [index, reason] of iterateTopLevel(tagCode)) {
+            if (reason == "{")
+                bracketIndex = index;
+        }
+        if (bracketIndex == -1) {
+            throw Error(`Invalid include tag: ${tagCode}`);
+        }
+        file = tagCode.slice(0, bracketIndex).trim();
+        data = tagCode.slice(bracketIndex).trim();
+    }
+    const { dataVarname } = env.options;
+    return `{
+    const __tmp = await __env.run(${file},
+      {...${dataVarname}${data ? `, ...${data}` : ""}},
+      __file
+    );
+    ${output} += ${env.compileFilters(tokens, "__tmp.content")};
+  }`;
+}

package/plugins/mod.js

@@ -0,0 +1,30 @@
+import ifTag from "./if.js";
+import forTag from "./for.js";
+import includeTag from "./include.js";
+import setTag from "./set.js";
+import jsTag from "./js.js";
+import layoutTag from "./layout.js";
+import functionTag from "./function.js";
+import importTag from "./import.js";
+import exportTag from "./export.js";
+import echoTag from "./echo.js";
+import escape from "./escape.js";
+import unescape from "./unescape.js";
+import trim from "./trim.js";
+export default function () {
+    return (env) => {
+        env.use(ifTag());
+        env.use(forTag());
+        env.use(jsTag());
+        env.use(includeTag());
+        env.use(setTag());
+        env.use(layoutTag());
+        env.use(functionTag());
+        env.use(importTag());
+        env.use(exportTag());
+        env.use(echoTag());
+        env.use(escape());
+        env.use(unescape());
+        env.use(trim());
+    };
+}

package/{esm/plugins → plugins}/set.js

@@ -17,11 +17,12 @@ function setTag(env, code, _output, tokens) {
         }
         const [, variable, value] = match;
         const val = env.compileFilters(tokens, value);
-        return `${dataVarname}["${variable}"] = ${val};`;
+        return `var ${variable} = ${dataVarname}["${variable}"] = ${val};`;
     }
     // Value is captured (eg: {{ set foo }}bar{{ /set }})
     const compiled = [];
-    const subvarName = `${dataVarname}["${expression.trim()}"]`;
+    const varName = expression.trim();
+    const subvarName = `${dataVarname}["${varName}"]`;
     const compiledFilters = env.compileFilters(tokens, subvarName);
     compiled.push(`${subvarName} = "";`);
     compiled.push(...env.compileTokens(tokens, subvarName, ["/set"]));
@@ -29,6 +30,6 @@ function setTag(env, code, _output, tokens) {
         throw new Error(`Missing closing tag for set tag: ${code}`);
     }
     tokens.shift();
-    compiled.push(`${subvarName} = ${compiledFilters};`);
+    compiled.push(`var ${varName} = ${subvarName} = ${compiledFilters};`);
     return compiled.join("\n");
 }

package/plugins/unescape.js

@@ -0,0 +1,25 @@
+const NAMED_ENTITIES = /&(apos|quot|amp|lt|gt);/g;
+const CHAR_REF = /&#(x[0-9A-F]{1,6}|[0-9]{1,7});/gi;
+const entities = {
+    apos: "'",
+    quot: '"',
+    amp: "&",
+    lt: "<",
+    gt: ">",
+};
+export default function () {
+    return (env) => {
+        env.filters.unescape = (value) => {
+            if (!value)
+                return "";
+            return value.toString().replace(NAMED_ENTITIES, (_, name) => {
+                return entities[name];
+            }).replace(CHAR_REF, (full, number) => {
+                const parsed = Number(`0${number}`);
+                if (parsed > 0x10FFFF)
+                    return full;
+                return String.fromCodePoint(parsed);
+            });
+        };
+    };
+}

package/prism-vento.js

@@ -0,0 +1,26 @@
+Prism.languages.vento = {
+  "delimiter": {
+    pattern: /\{{2}[->]?|-?\}{2}/,
+    alias: "punctuation",
+    lookbehind: true,
+  },
+  "comment": /^#[\s\S]*#$/,
+  "javascript": {
+    pattern: /\s*\S[\s\S]*/,
+    alias: "language-javascript",
+    inside: Prism.languages.javascript,
+  },
+};
+
+Prism.hooks.add("before-tokenize", function (env) {
+  const ventoPattern = /\{{2}[\s\S]+\}{2}/g;
+  Prism.languages["markup-templating"].buildPlaceholders(
+    env,
+    "vento",
+    ventoPattern,
+  );
+});
+
+Prism.hooks.add("after-tokenize", function (env) {
+  Prism.languages["markup-templating"].tokenizePlaceholders(env, "vento");
+});

package/types/browser.d.ts

@@ -0,0 +1,8 @@
+import { Environment, type Loader } from "./core/environment.d.ts";
+export interface Options {
+    includes: URL | Loader;
+    autoDataVarname?: boolean;
+    dataVarname?: string;
+    autoescape?: boolean;
+}
+export default function (options: Options): Environment;

package/{esm/src → types/core}/environment.d.ts

@@ -1,5 +1,4 @@
-import "../_dnt.polyfills.js";
-import { Token } from "./tokenizer.js";
+import { Token } from "./tokenizer.d.ts";
 export interface TemplateResult {
     content: string;
     [key: string]: unknown;
@@ -29,7 +28,7 @@ export interface TemplateSource {
     data?: Record<string, unknown>;
 }
 export interface Loader {
-    load(file: string): TemplateSource | Promise<TemplateSource>;
+    load(file: string): Promise<TemplateSource>;
     resolve(from: string, file: string): string;
 }
 export interface Options {
@@ -39,7 +38,7 @@ export interface Options {
     autoDataVarname: boolean;
 }
 export declare class Environment {
-    cache: Map<string, Template>;
+    cache: Map<string, Template | Promise<Template>>;
     options: Options;
     tags: Tag[];
     tokenPreprocessors: TokenPreprocessor[];
@@ -47,7 +46,7 @@ export declare class Environment {
     utils: Record<string, unknown>;
     constructor(options: Options);
     use(plugin: Plugin): void;
-    run(file: string, data: Record<string, unknown>, from?: string): Promise<TemplateResult>;
+    run(file: string, data?: Record<string, unknown>, from?: string): Promise<TemplateResult>;
     runString(source: string, data?: Record<string, unknown>, file?: string): Promise<TemplateResult>;
     runStringSync(source: string, data?: Record<string, unknown>): TemplateResult;
     compile(source: string, path?: string, defaults?: Record<string, unknown>, sync?: false): Template;
@@ -57,4 +56,3 @@ export declare class Environment {
     compileTokens(tokens: Token[], outputVar?: string, stopAt?: string[]): string[];
     compileFilters(tokens: Token[], output: string, autoescape?: boolean): string;
 }
-//# sourceMappingURL=environment.d.ts.map

package/{esm/src → types/core}/errors.d.ts

@@ -7,10 +7,6 @@ export declare class TemplateError extends VentoBaseError {
     position: number;
     constructor(path?: string, source?: string, position?: number, cause?: Error);
 }
-export declare class TransformError extends VentoBaseError {
-    position: number;
-    constructor(message: string, position?: number, cause?: Error);
-}
 /** Returns the number and code of the errored line */
 export declare function errorLine(source: string, position: number): {
     line: number;
@@ -18,4 +14,3 @@ export declare function errorLine(source: string, position: number): {
     code: string;
 };
 export {};
-//# sourceMappingURL=errors.d.ts.map

package/types/core/js.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This function iterates over the top-level scope of a JavaScript source code
+ * string. It yields pairs of the index and the type of each top-level element
+ * found.
+ *
+ * @example `{ foo: { bar: 1 } }` will yield:
+ * - [0, "{", Set[]]                for the first opening brace
+ * - [18, "}", Set['foo', 'bar']]   for the _second_ closing brace
+ * - [18, "", Set['foo', 'bar']]    for the end of the string
+ */
+export default function iterateTopLevel(source: string, start?: number): Generator<[number, string, Set<string>]>;

package/types/core/reserved.d.ts

@@ -0,0 +1,2 @@
+declare const variables: Set<string>;
+export default variables;

package/{esm/src → types/core}/tokenizer.d.ts

@@ -1,15 +1,8 @@
-import "../_dnt.polyfills.js";
 export type TokenType = "string" | "tag" | "filter" | "comment";
 export type Token = [TokenType, string, number?];
-export interface TokenizeResult {
-    tokens: Token[];
-    position: number;
-    error: Error | undefined;
-}
-export default function tokenize(source: string): TokenizeResult;
+export default function tokenize(source: string): Token[];
 /**
  * Parse a tag and return the indexes of the start and end brackets, and the filters between.
  * For example: {{ tag |> filter1 |> filter2 }} => [2, 9, 20, 31]
  */
 export declare function parseTag(source: string): number[];
-//# sourceMappingURL=tokenizer.d.ts.map