ventojs 0.6.0

package/esm/plugins/escape.js

@@ -0,0 +1,16 @@
+export default function () {
+    return (env) => {
+        env.filters.escape = escape;
+    };
+}
+const escapeMap = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;",
+    "`": "&#x60;",
+};
+function escape(str) {
+    return str.replace(/[&<>"'`]/g, (match) => escapeMap[match]);
+}

package/esm/plugins/for.d.ts

@@ -0,0 +1,2 @@
+import type { Environment } from "../src/environment.js";
+export default function (): (env: Environment) => void;

package/esm/plugins/for.js

@@ -0,0 +1,48 @@
+export default function () {
+    return (env) => {
+        env.tags.push(forTag);
+        env.utils.toIterator = toIterator;
+    };
+}
+function forTag(env, code, output, tokens) {
+    if (!code.startsWith("for ")) {
+        return;
+    }
+    const compiled = [];
+    const match = code.match(/^for\s+(await\s+)?(\w+)(?:,\s*(\w+))?\s+of\s+([\s|\S]+)$/);
+    if (!match) {
+        throw new Error(`Invalid for loop: ${code}`);
+    }
+    const [_, aw, var1, var2, collection] = match;
+    if (var2) {
+        compiled.push(`for ${aw || ""}(let [${var1}, ${var2}] of __env.utils.toIterator(${env.compileFilters(tokens, collection)}, true)) {`);
+    }
+    else {
+        compiled.push(`for ${aw || ""}(let ${var1} of __env.utils.toIterator(${env.compileFilters(tokens, collection)})) {`);
+    }
+    compiled.push(...env.compileTokens(tokens, output, ["/for"]));
+    tokens.shift();
+    compiled.push("}");
+    return compiled.join("\n");
+}
+function toIterator(item, withKeys = false) {
+    if (item === undefined || item === null) {
+        return [];
+    }
+    if (Array.isArray(item)) {
+        return withKeys ? Object.entries(item) : item;
+    }
+    if (typeof item === "function") {
+        return toIterator(item(), withKeys);
+    }
+    if (typeof item === "object" && item !== null) {
+        return withKeys ? Object.entries(item) : Object.values(item);
+    }
+    if (typeof item === "string") {
+        return toIterator(item.split(""), withKeys);
+    }
+    if (typeof item === "number") {
+        return toIterator(new Array(item).fill(0).map((_, i) => i + 1), withKeys);
+    }
+    return toIterator([item], withKeys);
+}

package/esm/plugins/if.d.ts

@@ -0,0 +1,2 @@
+import type { Environment } from "../src/environment.js";
+export default function (): (env: Environment) => void;

package/esm/plugins/if.js

@@ -0,0 +1,32 @@
+export default function () {
+    return (env) => {
+        env.tags.push(ifTag);
+        env.tags.push(elseTag);
+    };
+}
+function ifTag(env, code, output, tokens) {
+    if (!code.startsWith("if ")) {
+        return;
+    }
+    const condition = code.replace(/^if\s+/, "").trim();
+    const compiled = [];
+    compiled.push(`if (${condition}) {`);
+    compiled.push(...env.compileTokens(tokens, output, ["/if"]));
+    tokens.shift();
+    compiled.push("}");
+    return compiled.join("\n");
+}
+function elseTag(_env, code) {
+    if (!code.startsWith("else ") && code !== "else") {
+        return;
+    }
+    const match = code.match(/^else(\s+if\s+(.*))?$/);
+    if (!match) {
+        throw new Error(`Invalid else: ${code}`);
+    }
+    const [_, ifTag, condition] = match;
+    if (ifTag) {
+        return `} else if (${condition}) {`;
+    }
+    return "} else {";
+}

package/esm/plugins/include.d.ts

@@ -0,0 +1,2 @@
+import type { Environment } from "../src/environment.js";
+export default function (): (env: Environment) => void;

package/esm/plugins/include.js

@@ -0,0 +1,16 @@
+export default function () {
+    return (env) => {
+        env.tags.push(includeTag);
+    };
+}
+function includeTag(_env, code, output) {
+    if (!code.startsWith("include ")) {
+        return;
+    }
+    const match = code?.match(/^include\s+([^{]+|`[^`]+`)+(?:\{([\s|\S]*)\})?$/);
+    if (!match) {
+        throw new Error(`Invalid include: ${code}`);
+    }
+    const [_, file, data] = match;
+    return `${output} += await __env.run(${file}, {...__data${data ? `, ${data}` : ""}}, __file);`;
+}

package/esm/plugins/js.d.ts

@@ -0,0 +1,2 @@
+import type { Environment } from "../src/environment.js";
+export default function (): (env: Environment) => void;

package/esm/plugins/js.js

@@ -0,0 +1,11 @@
+export default function () {
+    return (env) => {
+        env.tags.push(jsTag);
+    };
+}
+function jsTag(_env, code) {
+    if (!code.startsWith("> ")) {
+        return;
+    }
+    return code.replace(/^>\s+/, "");
+}

package/esm/plugins/layout.d.ts

@@ -0,0 +1,2 @@
+import type { Environment } from "../src/environment.js";
+export default function (): (env: Environment) => void;

package/esm/plugins/layout.js

@@ -0,0 +1,29 @@
+export default function () {
+    return (env) => {
+        env.tags.push(layoutTag);
+    };
+}
+function layoutTag(env, code, output, tokens) {
+    if (!code.startsWith("layout ")) {
+        return;
+    }
+    const match = code?.match(/^layout\s+([^{]+|`[^`]+`)+(?:\{([\s|\S]*)\})?$/);
+    if (!match) {
+        throw new Error(`Invalid wrap: ${code}`);
+    }
+    const [_, file, data] = match;
+    const varname = "__content";
+    const compiled = [];
+    const compiledFilters = env.compileFilters(tokens, varname);
+    compiled.push("{");
+    compiled.push(`var ${varname} = "";`);
+    compiled.push(...env.compileTokens(tokens, varname, ["/layout"]));
+    if (tokens.length && (tokens[0][0] !== "tag" || tokens[0][1] !== "/layout")) {
+        throw new Error(`Missing closing tag for layout tag: ${code}`);
+    }
+    tokens.shift();
+    compiled.push(`${varname} = ${compiledFilters};`);
+    compiled.push(`${output} += await __env.run(${file}, {...__data${data ? `, ${data}` : ""}, content: ${varname}}, __file);`);
+    compiled.push("}");
+    return compiled.join("\n");
+}

package/esm/plugins/set.d.ts

@@ -0,0 +1,2 @@
+import type { Environment } from "../src/environment.js";
+export default function (): (env: Environment) => void;

package/esm/plugins/set.js

@@ -0,0 +1,44 @@
+export default function () {
+    return (env) => {
+        env.tags.push(setTag);
+    };
+}
+function setTag(env, code, _output, tokens) {
+    if (!code.startsWith("set ")) {
+        return;
+    }
+    const expression = code.replace(/^set\s+/, "");
+    // Value is set (e.g. {{ set foo = "bar" }})
+    if (expression.includes("=")) {
+        const match = code.match(/^set\s+([\w]+)\s*=\s*([\s\S]+)$/);
+        if (!match) {
+            throw new Error(`Invalid set tag: ${code}`);
+        }
+        const [, variable, value] = match;
+        const val = env.compileFilters(tokens, value);
+        return `if (__data.hasOwnProperty("${variable}")) {
+      ${variable} = ${val};
+    } else {
+      var ${variable} = ${val};
+    }
+    __data["${variable}"] = ${variable};
+    `;
+    }
+    // Value is captured (eg: {{ set foo }}bar{{ /set }})
+    const compiled = [];
+    const compiledFilters = env.compileFilters(tokens, expression);
+    compiled.push(`if (__data.hasOwnProperty("${expression}")) {
+    ${expression} = "";
+  } else {
+    var ${expression} = "";
+  }
+  `);
+    compiled.push(...env.compileTokens(tokens, expression, ["/set"]));
+    if (tokens.length && (tokens[0][0] !== "tag" || tokens[0][1] !== "/set")) {
+        throw new Error(`Missing closing tag for set tag: ${code}`);
+    }
+    tokens.shift();
+    compiled.push(`${expression} = ${compiledFilters};`);
+    compiled.push(`__data["${expression.trim()}"] = ${expression};`);
+    return compiled.join("\n");
+}

package/esm/src/environment.d.ts

@@ -0,0 +1,29 @@
+import { Token } from "./tokenizer.js";
+import type { Loader } from "./loader.js";
+export interface Template {
+    (data?: Record<string, unknown>): Promise<string>;
+    code: string;
+    file?: string;
+}
+export type Tag = (env: Environment, code: string, output: string, tokens: Token[]) => string | undefined;
+export type Filter = (...args: any[]) => any;
+export type Plugin = (env: Environment) => void;
+export interface Options {
+    loader: Loader;
+    dataVarname?: string;
+}
+export declare class Environment {
+    cache: Map<string, Template>;
+    options: Options;
+    tags: Tag[];
+    filters: Record<string, Filter>;
+    utils: Record<string, unknown>;
+    constructor(options: Options);
+    use(plugin: Plugin): void;
+    run(file: string, data: Record<string, unknown>, from?: string): Promise<string>;
+    runString(source: string, data?: Record<string, unknown>, file?: string): Promise<string>;
+    compile(source: string, path?: string, defaults?: Record<string, unknown>): Template;
+    load(file: string, from?: string): Promise<Template>;
+    compileTokens(tokens: Token[], outputVar?: string, stopAt?: string[]): string[];
+    compileFilters(tokens: Token[], output: string): string;
+}

package/esm/src/environment.js

@@ -0,0 +1,136 @@
+import * as dntShim from "../_dnt.shims.js";
+import tokenize from "./tokenizer.js";
+export class Environment {
+    cache = new Map();
+    options;
+    tags = [];
+    filters = {};
+    utils = {};
+    constructor(options) {
+        this.options = options;
+    }
+    use(plugin) {
+        plugin(this);
+    }
+    async run(file, data, from) {
+        const template = await this.load(file, from);
+        return await template(data);
+    }
+    async runString(source, data, file) {
+        if (file) {
+            const cached = this.cache.get(file);
+            if (cached) {
+                return await cached(data);
+            }
+            const template = this.compile(source, file);
+            this.cache.set(file, template);
+            return await template(data);
+        }
+        const template = this.compile(source, file);
+        return await template(data);
+    }
+    compile(source, path, defaults) {
+        try {
+            const tokens = tokenize(source);
+            const code = this.compileTokens(tokens).join("\n");
+            const constructor = new Function("__file", "__env", "__defaults", `return async function (__data) {
+          try {
+            __data = Object.assign({}, __defaults, __data);
+            const ${this.options.dataVarname} = __data;
+            let __output = "";
+            with (__data) {
+              ${code}
+            }
+            return __output;
+          } catch (cause) {
+            throw new Error(\`Error rendering template: \${__file}\`, { cause });
+          }
+        }
+        `);
+            // console.log(code);
+            const template = constructor(path, this, defaults);
+            template.file = path;
+            template.code = code;
+            return template;
+        }
+        catch (cause) {
+            throw new Error(`Error compiling template: ${path || source}`, { cause });
+        }
+    }
+    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);
+            const template = this.compile(source, path, data);
+            this.cache.set(file, template);
+        }
+        return this.cache.get(file);
+    }
+    compileTokens(tokens, outputVar = "__output", stopAt) {
+        const compiled = [];
+        tokens: while (tokens.length > 0) {
+            if (stopAt && tokens[0][0] === "tag" && stopAt.includes(tokens[0][1])) {
+                break;
+            }
+            const [type, code] = tokens.shift();
+            if (type === "comment") {
+                continue;
+            }
+            if (type === "string" || type === "raw") {
+                compiled.push(`${outputVar} += \`${code}\`;`);
+                continue;
+            }
+            if (type === "tag") {
+                for (const tag of this.tags) {
+                    const compiledTag = tag(this, code, outputVar, tokens);
+                    if (typeof compiledTag === "string") {
+                        compiled.push(compiledTag);
+                        continue tokens;
+                    }
+                }
+                // Unknown tag, just print it
+                const expression = this.compileFilters(tokens, code);
+                compiled.push(`${outputVar} += (${expression}) ?? "";`);
+                continue;
+            }
+            throw new Error(`Unknown token type "${type}"`);
+        }
+        return compiled;
+    }
+    compileFilters(tokens, output) {
+        while (tokens.length > 0 && tokens[0][0] === "filter") {
+            const [, code] = tokens.shift();
+            const match = code.match(/^(await\s+)?([\w.]+)(?:\((.*)\))?$/);
+            if (!match) {
+                throw new Error(`Invalid filter: ${code}`);
+            }
+            const [_, isAsync, name, args] = match;
+            if (!this.filters[name]) {
+                // If a global function
+                if (isGlobal(name)) {
+                    output = `${isAsync ? "await " : ""}${name}(${output}${args ? `, ${args}` : ""})`;
+                }
+                else {
+                    // It's a prototype's method (e.g. `String.toUpperCase()`)
+                    output = `${isAsync ? "await " : ""}(${output})?.${name}?.(${args ? args : ""})`;
+                }
+            }
+            else {
+                // It's a filter (e.g. filters.upper())
+                output = `${isAsync ? "await " : ""}__env.filters.${name}(${output}${args ? `, ${args}` : ""})`;
+            }
+        }
+        return output;
+    }
+}
+function isGlobal(name) {
+    // @ts-ignore TS doesn't know about globalThis
+    if (dntShim.dntGlobalThis[name]) {
+        return true;
+    }
+    if (name.includes(".")) {
+        const [obj, prop] = name.split(".");
+        // @ts-ignore TS doesn't know about globalThis
+        return typeof dntShim.dntGlobalThis[obj]?.[prop] === "function";
+    }
+}

package/esm/src/loader.d.ts

@@ -0,0 +1,14 @@
+export interface TemplateSource {
+    source: string;
+    data?: Record<string, unknown>;
+}
+export interface Loader {
+    load(file: string): TemplateSource | Promise<TemplateSource>;
+    resolve(from: string, file: string): string;
+}
+export declare class FileLoader implements Loader {
+    #private;
+    constructor(root: string);
+    load(file: string): Promise<TemplateSource>;
+    resolve(from: string, file: string): string;
+}

package/esm/src/loader.js

@@ -0,0 +1,19 @@
+import * as dntShim from "../_dnt.shims.js";
+import { path } from "../deps.js";
+export class FileLoader {
+    #root;
+    constructor(root) {
+        this.#root = root;
+    }
+    async load(file) {
+        return {
+            source: await dntShim.Deno.readTextFile(file),
+        };
+    }
+    resolve(from, file) {
+        if (file.startsWith(".")) {
+            return path.join(path.dirname(from), file);
+        }
+        return path.join(this.#root, file);
+    }
+}

package/esm/src/tokenizer.d.ts

@@ -0,0 +1,8 @@
+export type TokenType = "string" | "tag" | "filter" | "comment" | "raw";
+export type Token = [TokenType, string];
+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[];

package/esm/src/tokenizer.js

@@ -0,0 +1,197 @@
+export default function tokenize(source) {
+    const tokens = [];
+    let type = "string";
+    let trimNext = false;
+    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()]);
+                trimNext = false;
+            }
+            else {
+                tokens.push([type, code]);
+            }
+            if (index === -1) {
+                break;
+            }
+            source = source.slice(index);
+            // Check if it's a {{raw}} tag
+            const raw = parseRawTag(source);
+            if (raw) {
+                const rawCode = source.slice(raw[0], raw[1]);
+                tokens.push(["raw", rawCode]);
+                source = source.slice(raw[2]);
+                type = "string";
+                continue;
+            }
+            type = source.startsWith("{{#") ? "comment" : "tag";
+            continue;
+        }
+        if (type === "comment") {
+            source = source.slice(3);
+            const index = source.indexOf("#}}");
+            const comment = index === -1 ? source : source.slice(0, index);
+            tokens.push([type, comment]);
+            if (index === -1) {
+                break;
+            }
+            source = source.slice(index + 3);
+            type = "string";
+            continue;
+        }
+        if (type === "tag") {
+            const indexes = parseTag(source);
+            const lastIndex = indexes.length - 1;
+            indexes.reduce((prev, curr, index) => {
+                let 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;
+                    }
+                    tokens.push([type, code.trim()]);
+                    return curr;
+                }
+                // Right trim
+                if (index === lastIndex && code.endsWith("-")) {
+                    code = code.slice(0, -1);
+                    trimNext = true;
+                }
+                // Filters
+                tokens.push(["filter", code.trim()]);
+                return curr;
+            });
+            source = source.slice(indexes[indexes.length - 1]);
+            type = "string";
+            continue;
+        }
+    }
+    return tokens;
+}
+/**
+ * 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 function parseTag(source) {
+    const length = source.length;
+    const statuses = [];
+    const indexes = [2];
+    let index = 0;
+    while (index < length) {
+        const char = source.charAt(index++);
+        switch (char) {
+            // Detect start brackets
+            case "{": {
+                const status = statuses[0];
+                if (status === "literal" && source.charAt(index - 2) === "$") {
+                    statuses.unshift("bracket");
+                }
+                else if (status !== "comment" && status !== "single-quote" &&
+                    status !== "double-quote" && status !== "literal") {
+                    statuses.unshift("bracket");
+                }
+                break;
+            }
+            // Detect end brackets
+            case "}": {
+                const status = statuses[0];
+                if (status === "bracket") {
+                    statuses.shift();
+                    if (statuses.length === 0) {
+                        indexes.push(index);
+                        return indexes;
+                    }
+                }
+                break;
+            }
+            // Detect double quotes
+            case '"': {
+                const status = statuses[0];
+                if (status === "double-quote") {
+                    statuses.shift();
+                }
+                else if (status !== "comment" &&
+                    status !== "single-quote" &&
+                    status !== "literal") {
+                    statuses.unshift("double-quote");
+                }
+                break;
+            }
+            // Detect single quotes
+            case "'": {
+                const status = statuses[0];
+                if (status === "single-quote") {
+                    statuses.shift();
+                }
+                else if (status !== "comment" &&
+                    status !== "double-quote" &&
+                    status !== "literal") {
+                    statuses.unshift("single-quote");
+                }
+                break;
+            }
+            // Detect literals
+            case "`": {
+                const status = statuses[0];
+                if (status === "literal") {
+                    statuses.shift();
+                }
+                else if (status !== "comment" &&
+                    status !== "double-quote" &&
+                    status !== "single-quote") {
+                    statuses.unshift("literal");
+                }
+                break;
+            }
+            // Detect comments
+            case "/": {
+                const status = statuses[0];
+                if (status !== "single-quote" && status !== "double-quote" &&
+                    status !== "literal") {
+                    if (source.charAt(index) === "*") {
+                        statuses.unshift("comment");
+                    }
+                    else if (status === "comment" &&
+                        source.charAt(index - 2) === "*") {
+                        statuses.shift();
+                    }
+                }
+                break;
+            }
+            // Detect filters
+            case "|": {
+                const status = statuses[0];
+                if (status === "bracket" && source.charAt(index) === ">") {
+                    indexes.push(index + 1);
+                }
+                break;
+            }
+        }
+    }
+    throw new Error("Unclosed tag");
+}
+function parseRawTag(source) {
+    const startResult = source.match(/^{{\s*raw\s*}}/);
+    if (!startResult) {
+        return;
+    }
+    const endResult = source.match(/{{\s*\/raw\s*}}/);
+    if (!endResult) {
+        throw new Error("Unclosed raw tag");
+    }
+    return [
+        startResult[0].length,
+        endResult.index,
+        endResult.index + endResult[0].length,
+    ];
+}

package/esm/test/comment.test.d.ts

@@ -0,0 +1 @@
+import "../_dnt.test_polyfills.js";

package/esm/test/escape.test.d.ts

@@ -0,0 +1 @@
+import "../_dnt.test_polyfills.js";

package/esm/test/for.test.d.ts

@@ -0,0 +1 @@
+import "../_dnt.test_polyfills.js";

package/esm/test/if.test.d.ts

@@ -0,0 +1 @@
+import "../_dnt.test_polyfills.js";

package/esm/test/include.test.d.ts

@@ -0,0 +1 @@
+import "../_dnt.test_polyfills.js";

package/esm/test/js.test.d.ts

@@ -0,0 +1 @@
+import "../_dnt.test_polyfills.js";

package/esm/test/layout.test.d.ts

@@ -0,0 +1 @@
+import "../_dnt.test_polyfills.js";

package/esm/test/print.test.d.ts

@@ -0,0 +1 @@
+import "../_dnt.test_polyfills.js";

package/esm/test/raw.test.d.ts

@@ -0,0 +1 @@
+import "../_dnt.test_polyfills.js";

package/esm/test/set.test.d.ts

@@ -0,0 +1 @@
+import "../_dnt.test_polyfills.js";

package/esm/test/tokenizer.test.d.ts

@@ -0,0 +1 @@
+import "../_dnt.test_polyfills.js";