ventojs 0.6.0 → 0.7.2

package/esm/deps/deno.land/std@0.201.0/path/win32.d.ts

@@ -0,0 +1,15 @@
+export declare const sep = "\\";
+export declare const delimiter = ";";
+export { windowsResolve as resolve } from "./_resolve.js";
+export { windowsNormalize as normalize } from "./_normalize.js";
+export { windowsIsAbsolute as isAbsolute } from "./_is_absolute.js";
+export { windowsJoin as join } from "./_join.js";
+export { windowsRelative as relative } from "./_relative.js";
+export { windowsToNamespacedPath as toNamespacedPath } from "./_to_namespaced_path.js";
+export { windowsDirname as dirname } from "./_dirname.js";
+export { windowsBasename as basename } from "./_basename.js";
+export { windowsExtname as extname } from "./_extname.js";
+export { windowsFormat as format } from "./_format.js";
+export { windowsParse as parse } from "./_parse.js";
+export { windowsFromFileUrl as fromFileUrl } from "./_from_file_url.js";
+export { windowsToFileUrl as toFileUrl } from "./_to_file_url.js";

package/esm/deps/deno.land/std@0.201.0/path/win32.js

@@ -0,0 +1,19 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright the Browserify authors. MIT License.
+// Ported from https://github.com/browserify/path-browserify/
+// This module is browser compatible.
+export const sep = "\\";
+export const delimiter = ";";
+export { windowsResolve as resolve } from "./_resolve.js";
+export { windowsNormalize as normalize } from "./_normalize.js";
+export { windowsIsAbsolute as isAbsolute } from "./_is_absolute.js";
+export { windowsJoin as join } from "./_join.js";
+export { windowsRelative as relative } from "./_relative.js";
+export { windowsToNamespacedPath as toNamespacedPath } from "./_to_namespaced_path.js";
+export { windowsDirname as dirname } from "./_dirname.js";
+export { windowsBasename as basename } from "./_basename.js";
+export { windowsExtname as extname } from "./_extname.js";
+export { windowsFormat as format } from "./_format.js";
+export { windowsParse as parse } from "./_parse.js";
+export { windowsFromFileUrl as fromFileUrl } from "./_from_file_url.js";
+export { windowsToFileUrl as toFileUrl } from "./_to_file_url.js";

package/esm/deps.d.ts

@@ -1 +1 @@
-export * as path from "./deps/deno.land/std@0.178.0/path/mod.js";
+export * as path from "./deps/deno.land/std@0.201.0/path/mod.js";

package/esm/deps.js

@@ -1 +1 @@
-export * as path from "./deps/deno.land/std@0.178.0/path/mod.js";
+export * as path from "./deps/deno.land/std@0.201.0/path/mod.js";

package/esm/mod.js

@@ -7,6 +7,9 @@ import includeTag from "./plugins/include.js";
 import setTag from "./plugins/set.js";
 import jsTag from "./plugins/js.js";
 import layoutTag from "./plugins/layout.js";
+import functionTag from "./plugins/function.js";
+import importTag from "./plugins/import.js";
+import exportTag from "./plugins/export.js";
 import escape from "./plugins/escape.js";
 export default function (options = {}) {
     const loader = typeof options.includes === "object"
@@ -23,6 +26,9 @@ export default function (options = {}) {
     env.use(includeTag());
     env.use(setTag());
     env.use(layoutTag());
+    env.use(functionTag());
+    env.use(importTag());
+    env.use(exportTag());
     env.use(escape());
     return env;
 }

package/esm/plugins/export.d.ts

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

package/esm/plugins/export.js

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

package/esm/plugins/function.d.ts

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

package/esm/plugins/function.js

@@ -0,0 +1,37 @@
+export default function () {
+    return (env) => {
+        env.tags.push(functionTag);
+    };
+}
+function functionTag(env, code, _output, tokens) {
+    if (!code.match(/(export\s+)?(async\s+)?function\s/)) {
+        return;
+    }
+    const match = code.match(/^(export\s+)?(async\s+)?function\s+(\w+)\s*(\([^)]+\))?$/);
+    if (!match) {
+        throw new Error(`Invalid function: ${code}`);
+    }
+    const [_, exp, as, name, args] = match;
+    const compiled = [];
+    compiled.push(`${as || ""} function ${name} ${args || "()"} {`);
+    compiled.push(`let __output = "";`);
+    if (exp) {
+        compiled.push(...env.compileTokens(tokens, "__output", ["/export"]));
+        if (tokens.length && (tokens[0][0] !== "tag" || tokens[0][1] !== "/export")) {
+            throw new Error(`Missing closing tag for export function tag: ${code}`);
+        }
+    }
+    else {
+        compiled.push(...env.compileTokens(tokens, "__output", ["/function"]));
+        if (tokens.length && (tokens[0][0] !== "tag" || tokens[0][1] !== "/function")) {
+            throw new Error(`Missing closing tag for function tag: ${code}`);
+        }
+    }
+    tokens.shift();
+    compiled.push(`return __output;`);
+    compiled.push(`}`);
+    if (exp) {
+        compiled.push(`__exports["${name}"] = ${name}`);
+    }
+    return compiled.join("\n");
+}

package/esm/plugins/import.d.ts

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

package/esm/plugins/import.js

@@ -0,0 +1,24 @@
+export default function () {
+    return (env) => {
+        env.tags.push(importTag);
+    };
+}
+function importTag(_env, code) {
+    if (!code.startsWith("import ")) {
+        return;
+    }
+    const match = code?.match(/^import\s+(\{[\s|\S]*\}|\w+)\s+from\s+(.+)$/);
+    if (!match) {
+        throw new Error(`Invalid import: ${code}`);
+    }
+    const [_, vars, file] = match;
+    const compiled = [];
+    compiled.push(`__tmp = await __env.run(${file}, {...__data}, __file);`);
+    if (vars.startsWith("{")) {
+        compiled.push(`let ${vars} = __tmp;`);
+    }
+    else {
+        compiled.push(`let ${vars} = __tmp;`);
+    }
+    return compiled.join("\n");
+}

package/esm/plugins/include.js

@@ -12,5 +12,11 @@ function includeTag(_env, code, output) {
         throw new Error(`Invalid include: ${code}`);
     }
     const [_, file, data] = match;
-    return `${output} += await __env.run(${file}, {...__data${data ? `, ${data}` : ""}}, __file);`;
+    return `{
+    __tmp = await __env.run(${file},
+      {...__data${data ? `, ${data}` : ""}},
+      __file
+    );
+    ${output} += __tmp.content;
+  }`;
 }

package/esm/plugins/layout.js

@@ -23,7 +23,11 @@ function layoutTag(env, code, output, tokens) {
     }
     tokens.shift();
     compiled.push(`${varname} = ${compiledFilters};`);
-    compiled.push(`${output} += await __env.run(${file}, {...__data${data ? `, ${data}` : ""}, content: ${varname}}, __file);`);
+    compiled.push(`__tmp = await __env.run(${file},
+      {...__data${data ? `, ${data}` : ""}, content: ${varname}},
+      __file
+    );
+    ${output} += __tmp.content;`);
     compiled.push("}");
     return compiled.join("\n");
 }

package/esm/src/environment.d.ts

@@ -1,7 +1,16 @@
 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<string>;
+    (data?: Record<string, unknown>): Promise<TemplateResult>;
+    code: string;
+    file?: string;
+}
+export interface TemplateSync {
+    (data?: Record<string, unknown>): TemplateResult;
     code: string;
     file?: string;
 }
@@ -20,9 +29,11 @@ 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<string>;
-    runString(source: string, data?: Record<string, unknown>, file?: string): Promise<string>;
-    compile(source: string, path?: string, defaults?: Record<string, unknown>): Template;
+    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;
     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

@@ -29,19 +29,24 @@ export class Environment {
         const template = this.compile(source, file);
         return await template(data);
     }
-    compile(source, path, defaults) {
+    runStringSync(source, data) {
+        const template = this.compile(source, "", {}, true);
+        return template(data);
+    }
+    compile(source, path, defaults, sync = false) {
         try {
             const tokens = tokenize(source);
             const code = this.compileTokens(tokens).join("\n");
-            const constructor = new Function("__file", "__env", "__defaults", `return async function (__data) {
+            const constructor = new Function("__file", "__env", "__defaults", `return${sync ? "" : " async"} function (__data) {
           try {
             __data = Object.assign({}, __defaults, __data);
             const ${this.options.dataVarname} = __data;
-            let __output = "";
+            let __tmp;
+            const __exports = { content: "" };
             with (__data) {
               ${code}
             }
-            return __output;
+            return __exports;
           } catch (cause) {
             throw new Error(\`Error rendering template: \${__file}\`, { cause });
           }
@@ -66,7 +71,7 @@ export class Environment {
         }
         return this.cache.get(file);
     }
-    compileTokens(tokens, outputVar = "__output", stopAt) {
+    compileTokens(tokens, outputVar = "__exports.content", stopAt) {
         const compiled = [];
         tokens: while (tokens.length > 0) {
             if (stopAt && tokens[0][0] === "tag" && stopAt.includes(tokens[0][1])) {
@@ -77,7 +82,9 @@ export class Environment {
                 continue;
             }
             if (type === "string" || type === "raw") {
-                compiled.push(`${outputVar} += \`${code}\`;`);
+                compiled.push(`${outputVar} += \`${code
+                    .replaceAll("`", "\\`")
+                    .replaceAll("${", "\\${")}\`;`);
                 continue;
             }
             if (type === "tag") {

package/package.json

@@ -1,11 +1,11 @@
 {
   "module": "./esm/mod.js",
   "name": "ventojs",
-  "version": "0.6.0",
+  "version": "0.7.2",
   "description": "🌬 A minimal but powerful template engine",
   "license": "MIT",
   "repository": "github:oscarotero/vento",
-  "homepage": "https://oscarotero.github.io/vento/",
+  "homepage": "https://vento.js.org/",
   "bugs": "https://github.com/oscarotero/vento/issues",
   "exports": {
     ".": {

package/esm/_dnt.test_polyfills.d.ts

@@ -1,11 +0,0 @@
-declare global {
-    interface Object {
-        /**
-         * Determines whether an object has a property with the specified name.
-         * @param o An object.
-         * @param v A property name.
-         */
-        hasOwn(o: object, v: PropertyKey): boolean;
-    }
-}
-export {};

package/esm/_dnt.test_shims.d.ts

@@ -1,5 +0,0 @@
-import { Deno } from "@deno/shim-deno";
-export { Deno } from "@deno/shim-deno";
-export declare const dntGlobalThis: Omit<typeof globalThis, "Deno"> & {
-    Deno: typeof Deno;
-};

package/esm/deps/deno.land/std@0.178.0/_util/asserts.d.ts

@@ -1,10 +0,0 @@
-/**
- * All internal non-test code, that is files that do not have `test` or `bench` in the name, must use the assertion functions within `_utils/asserts.ts` and not `testing/asserts.ts`. This is to create a separation of concerns between internal and testing assertions.
- */
-export declare class DenoStdInternalError extends Error {
-    constructor(message: string);
-}
-/** Make an assertion, if not `true`, then throw. */
-export declare function assert(expr: unknown, msg?: string): asserts expr;
-/** Use this to assert unreachable code. */
-export declare function unreachable(): never;

package/esm/deps/deno.land/std@0.178.0/_util/asserts.js

@@ -1,21 +0,0 @@
-// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-/**
- * All internal non-test code, that is files that do not have `test` or `bench` in the name, must use the assertion functions within `_utils/asserts.ts` and not `testing/asserts.ts`. This is to create a separation of concerns between internal and testing assertions.
- */
-export class DenoStdInternalError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "DenoStdInternalError";
-    }
-}
-/** Make an assertion, if not `true`, then throw. */
-export function assert(expr, msg = "") {
-    if (!expr) {
-        throw new DenoStdInternalError(msg);
-    }
-}
-/** Use this to assert unreachable code. */
-export function unreachable() {
-    throw new DenoStdInternalError("unreachable");
-}

package/esm/deps/deno.land/std@0.178.0/path/mod.d.ts

@@ -1,9 +0,0 @@
-import * as _win32 from "./win32.js";
-import * as _posix from "./posix.js";
-export declare const win32: typeof _win32;
-export declare const posix: typeof _posix;
-export declare const basename: typeof _posix.basename | typeof _win32.basename, delimiter: string, dirname: typeof _posix.dirname | typeof _win32.dirname, extname: typeof _posix.extname | typeof _win32.extname, format: typeof _posix.format | typeof _win32.format, fromFileUrl: typeof _posix.fromFileUrl | typeof _win32.fromFileUrl, isAbsolute: typeof _win32.isAbsolute | typeof _posix.isAbsolute, join: typeof _posix.join | typeof _win32.join, normalize: typeof _win32.normalize | typeof _posix.normalize, parse: typeof _posix.parse | typeof _win32.parse, relative: typeof _posix.relative | typeof _win32.relative, resolve: typeof _win32.resolve | typeof _posix.resolve, sep: string, toFileUrl: typeof _posix.toFileUrl | typeof _win32.toFileUrl, toNamespacedPath: typeof _posix.toNamespacedPath | typeof _win32.toNamespacedPath;
-export * from "./common.js";
-export { SEP, SEP_PATTERN } from "./separator.js";
-export * from "./_interface.js";
-export * from "./glob.js";

package/esm/deps/deno.land/std@0.178.0/path/posix.d.ts

@@ -1,86 +0,0 @@
-/// <reference types="node" />
-import type { FormatInputPathObject, ParsedPath } from "./_interface.js";
-export declare const sep = "/";
-export declare const delimiter = ":";
-/**
- * Resolves `pathSegments` into an absolute path.
- * @param pathSegments an array of path segments
- */
-export declare function resolve(...pathSegments: string[]): string;
-/**
- * Normalize the `path`, resolving `'..'` and `'.'` segments.
- * Note that resolving these segments does not necessarily mean that all will be eliminated.
- * A `'..'` at the top-level will be preserved, and an empty path is canonically `'.'`.
- * @param path to be normalized
- */
-export declare function normalize(path: string): string;
-/**
- * Verifies whether provided path is absolute
- * @param path to be verified as absolute
- */
-export declare function isAbsolute(path: string): boolean;
-/**
- * Join all given a sequence of `paths`,then normalizes the resulting path.
- * @param paths to be joined and normalized
- */
-export declare function join(...paths: string[]): string;
-/**
- * Return the relative path from `from` to `to` based on current working directory.
- * @param from path in current working directory
- * @param to path in current working directory
- */
-export declare function relative(from: string, to: string): string;
-/**
- * Resolves path to a namespace path
- * @param path to resolve to namespace
- */
-export declare function toNamespacedPath(path: string): string;
-/**
- * Return the directory path of a `path`.
- * @param path - path to extract the directory from.
- */
-export declare function dirname(path: string): string;
-/**
- * Return the last portion of a `path`.
- * Trailing directory separators are ignored, and optional suffix is removed.
- *
- * @param path - path to extract the name from.
- * @param [suffix] - suffix to remove from extracted name.
- */
-export declare function basename(path: string, suffix?: string): string;
-/**
- * Return the extension of the `path` with leading period.
- * @param path with extension
- * @returns extension (ex. for `file.ts` returns `.ts`)
- */
-export declare function extname(path: string): string;
-/**
- * Generate a path from `FormatInputPathObject` object.
- * @param pathObject with path
- */
-export declare function format(pathObject: FormatInputPathObject): string;
-/**
- * Return a `ParsedPath` object of the `path`.
- * @param path to process
- */
-export declare function parse(path: string): ParsedPath;
-/**
- * Converts a file URL to a path string.
- *
- * ```ts
- *      import { fromFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix.ts";
- *      fromFileUrl("file:///home/foo"); // "/home/foo"
- * ```
- * @param url of a file URL
- */
-export declare function fromFileUrl(url: string | URL): string;
-/**
- * Converts a path string to a file URL.
- *
- * ```ts
- *      import { toFileUrl } from "https://deno.land/std@$STD_VERSION/path/posix.ts";
- *      toFileUrl("/home/foo"); // new URL("file:///home/foo")
- * ```
- * @param path to convert to file URL
- */
-export declare function toFileUrl(path: string): URL;