ventojs 0.12.1 → 0.12.2

package/esm/src/environment.d.ts

@@ -1,54 +0,0 @@
-import { Token } from "./tokenizer.js";
-import type { Loader } from "./loader.js";
-export interface TemplateResult {
-    content: string;
-    [key: string]: unknown;
-}
-export interface Template {
-    (data?: Record<string, unknown>): Promise<TemplateResult>;
-    source: string;
-    code: string;
-    file?: string;
-}
-export interface TemplateSync {
-    (data?: Record<string, unknown>): TemplateResult;
-    source: string;
-    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>;
-    env: Environment;
-};
-export type Filter = (this: FilterThis, ...args: any[]) => any;
-export type Plugin = (env: Environment) => void;
-export interface Options {
-    loader: Loader;
-    dataVarname: string;
-    autoescape: boolean;
-    useWith: boolean;
-}
-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);
-    use(plugin: Plugin): void;
-    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;
-    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;
-    createError(path: string, source: string, position: number, cause: Error): Error;
-}
-/** Returns the number and code of the errored line */
-export declare function errorLine(source: string, pos: number): [number, number, string];

package/esm/src/environment.js

@@ -1,198 +0,0 @@
-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) {
-        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);
-    }
-    runStringSync(source, data) {
-        const template = this.compile(source, "", {}, true);
-        return template(data);
-    }
-    compile(source, path, defaults, sync = false) {
-        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: "" };
-          ${code}
-          return __exports;
-        } catch (cause) {
-          const template = __env.cache.get(__file);
-          throw __env.createError(__file, template?.source || "", __pos, cause);
-        }
-      }
-      `);
-        const template = constructor(path, this, defaults);
-        template.file = path;
-        template.code = code;
-        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)) {
-            // 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);
-        }
-        return this.cache.get(path);
-    }
-    compileTokens(tokens, outputVar = "__exports.content", stopAt) {
-        const compiled = [];
-        tokens: while (tokens.length > 0) {
-            if (stopAt && tokens[0][0] === "tag" && stopAt.includes(tokens[0][1])) {
-                break;
-            }
-            const [type, code, pos] = tokens.shift();
-            if (type === "comment") {
-                continue;
-            }
-            if (type === "string") {
-                compiled.push(`${outputVar} += ${JSON.stringify(code)};`);
-                continue;
-            }
-            if (type === "tag") {
-                compiled.push(`__pos = ${pos};`);
-                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, this.options.autoescape);
-                compiled.push(`${outputVar} += (${expression}) ?? "";`);
-                continue;
-            }
-            throw new Error(`Unknown token type "${type}"`);
-        }
-        return compiled;
-    }
-    compileFilters(tokens, output, autoescape = false) {
-        let unescaped = false;
-        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 (name === "safe") {
-                    unescaped = true;
-                }
-                else if (isGlobal(name)) {
-                    // If a global function
-                    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())
-                const { dataVarname } = this.options;
-                output = `${(isAsync || checkAsync(this.filters[name])) ? "await " : ""}__env.filters.${name}.call({data:${dataVarname},env:__env}, ${output}${args ? `, ${args}` : ""})`;
-            }
-        }
-        // Escape by default
-        if (autoescape && !unescaped) {
-            output = `__env.filters.escape(${output})`;
-        }
-        return output;
-    }
-    createError(path, source, position, cause) {
-        if (!source) {
-            return cause;
-        }
-        const [line, column, code] = errorLine(source, position);
-        return new Error(`Error in the template ${path}:${line}:${column}\n\n${code.trim()}\n\n> ${cause.message}\n`, { cause });
-    }
-}
-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";
-    }
-}
-/** Returns the number and code of the errored line */
-export function errorLine(source, pos) {
-    let line = 1;
-    let column = 1;
-    for (let index = 0; index < pos; index++) {
-        if (source[index] === "\n" ||
-            (source[index] === "\r" && source[index + 1] === "\n")) {
-            line++;
-            column = 1;
-            if (source[index] === "\r") {
-                index++;
-            }
-        }
-        else {
-            column++;
-        }
-    }
-    return [line, column, source.split("\n")[line - 1]];
-}
-function checkAsync(fn) {
-    return fn.constructor?.name === "AsyncFunction";
-}

package/esm/src/loader.d.ts

@@ -1,14 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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;
-/**
- * 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

@@ -1,221 +0,0 @@
-export default function tokenize(source) {
-    const tokens = [];
-    let type = "string";
-    let position = 0;
-    try {
-        while (source.length > 0) {
-            if (type === "string") {
-                const index = source.indexOf("{{");
-                const code = index === -1 ? source : source.slice(0, index);
-                tokens.push([type, code, position]);
-                if (index === -1) {
-                    break;
-                }
-                position += index;
-                source = source.slice(index);
-                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, position]);
-                if (index === -1) {
-                    break;
-                }
-                position += index + 3;
-                source = source.slice(index + 3);
-                type = "string";
-                continue;
-            }
-            if (type === "tag") {
-                const indexes = parseTag(source);
-                const lastIndex = indexes.length - 1;
-                let tag;
-                indexes.reduce((prev, curr, index) => {
-                    const code = source.slice(prev, curr - 2);
-                    // Tag
-                    if (index === 1) {
-                        tag = [type, code, position];
-                        tokens.push(tag);
-                        return curr;
-                    }
-                    // Filters
-                    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].match(/^\-?\s*echo\s*\-?$/)) {
-                    const end = source.match(/{{\-?\s*\/echo\s*\-?}}/);
-                    if (!end) {
-                        throw new Error("Unclosed echo tag");
-                    }
-                    const rawCode = source.slice(0, end.index);
-                    tag[1] = `echo ${JSON.stringify(rawCode)}`;
-                    const length = Number(end.index) + end[0].length;
-                    source = source.slice(length);
-                    position += length;
-                }
-                continue;
-            }
-        }
-    }
-    catch (error) {
-        return { tokens, position, error };
-    }
-    return { tokens, position, error: undefined };
-}
-/**
- * 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" &&
-                    status !== "regex" && status !== "line-comment") {
-                    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" &&
-                    status !== "regex" &&
-                    status !== "line-comment") {
-                    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" &&
-                    status !== "regex" &&
-                    status !== "line-comment") {
-                    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" &&
-                    status !== "regex" &&
-                    status !== "line-comment") {
-                    statuses.unshift("literal");
-                }
-                break;
-            }
-            // Detect comments and regex
-            case "/": {
-                const status = statuses[0];
-                if (status === "single-quote" || status === "double-quote" ||
-                    status === "literal" || status === "line-comment") {
-                    break;
-                }
-                // We are in a comment: close or ignore
-                if (status === "comment") {
-                    if (source.charAt(index - 2) === "*") {
-                        statuses.shift();
-                    }
-                    break;
-                }
-                // We are in a regex: close or ignore
-                if (status === "regex") {
-                    if (source.charAt(index - 2) !== "\\") {
-                        statuses.shift();
-                    }
-                    break;
-                }
-                // Start a new comment
-                if (source.charAt(index) === "*") {
-                    statuses.unshift("comment");
-                    break;
-                }
-                // Start a new line comment
-                if (source.charAt(index - 2) === "/") {
-                    statuses.unshift("line-comment");
-                    break;
-                }
-                // Start a new regex
-                const prev = prevChar(source, index - 1);
-                if (prev === "(" || prev === "=" || prev === ":" || prev === ",") {
-                    statuses.unshift("regex");
-                }
-                break;
-            }
-            // Detect end of line comments
-            case "\n": {
-                const status = statuses[0];
-                if (status === "line-comment") {
-                    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");
-}
-// Get the previous character in a string ignoring spaces, line breaks and tabs
-function prevChar(source, index) {
-    while (index > 0) {
-        const char = source.charAt(--index);
-        if (char !== " " && char !== "\n" && char !== "\r" && char !== "\t") {
-            return char;
-        }
-    }
-    return "";
-}

package/esm/src/transformer.d.ts

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