@samuelbines/nunjucks 0.0.3

package/dist/src/interpreter.js

@@ -0,0 +1,489 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderRootToString = renderRootToString;
+exports.renderAST = renderAST;
+//TODO: Sun 4th Jan 2026 [Expand and write tests for each type.]
+const environment_1 = require("./environment");
+const lib_1 = require("./lib");
+const nodes_1 = require("./nodes");
+const transformer_1 = require("./transformer");
+const runtime_1 = require("./runtime");
+const parser_1 = require("./parser");
+async function evalBinOp(node, st, fn) {
+    const left = await evalExpr(node.left, st);
+    const right = await evalExpr(node.right, st);
+    return fn(left, right);
+}
+function makeBlockFn(block, env, runtime) {
+    return async (context, frame) => {
+        const st = { env, context, frame: frame.push(true), runtime, buffer: [] };
+        await evalNode(block.body, st);
+        return st.buffer.join('');
+    };
+}
+async function registerBlocksFromAst(root, st) {
+    const blocks = (0, transformer_1.collectBlocks)(root);
+    for (const b of blocks) {
+        const name = b.name.value; // Block.name is Symbol in your AST
+        st.context.addBlock(name, makeBlockFn(b, st.env, st.runtime));
+    }
+}
+async function evalExtends(node, st) {
+    const parentStr = String(await evalExpr(node.template, st));
+    await registerBlocksFromAst(st.rootAst, st);
+    const info = await new Promise((resolve, reject) => {
+        st.env.getTemplateInfo(parentStr, { parentName: null }, (err, out) => err ? reject(err) : resolve(out));
+    });
+    const parentAst = (0, transformer_1.transform)((0, parser_1.parse)(info.src, [], st.env), []);
+    // const parentTpl = await st.env.getTemplate(parentStr,undefined, {eagerCompile:true});
+    // p.err('Parent string is: ',parentStr,  parentTpl.ast, parentTpl.root)
+    // const parentAst: Root = parentTpl.ast ?? parentTpl.root; 
+    // if (!parentAst) {
+    //   throw st.runtime.handleError(
+    //     new Error(`Parent template "${parentStr}" has no AST loaded`),
+    //     node.lineno,
+    //     node.colno
+    //   );
+    // }
+    // const rendered = await new Promise<string>((resolve, reject) => {
+    //   parentTpl.render(st.context.getVariables?.() ?? st.context, (err: any, res: string) =>
+    //     err ? reject(err) : resolve(res)
+    //   );
+    // });
+    const parentState = {
+        ...st,
+        rootAst: parentAst,
+        buffer: [],
+        didExtend: false,
+    };
+    await evalNode(parentAst, parentState);
+    write(st, parentState.buffer.join(""));
+    // write(st, rendered);
+    st.didExtend = true;
+}
+async function evalNodeListStmt(node, st) {
+    for (const child of node.children) {
+        await evalNode(child, st);
+        if (st.didExtend)
+            return;
+    }
+}
+async function evalRoot(node, st) {
+    await registerBlocksFromAst(node, st);
+    await evalNodeListStmt(node, st);
+}
+async function evalBlock(node, st) {
+    const name = node.name.value;
+    const fn = st.context.getBlock(name); // whatever your API is
+    if (!fn)
+        return;
+    const rendered = await fn(st.context, st.frame);
+    write(st, rendered);
+}
+async function evalBinOpHp(node, st, op) {
+    switch (op) {
+        case '||': {
+            const left = await evalExpr(node.left, st);
+            return left ? left : await evalExpr(node.right, st);
+        }
+        case '&&': {
+            const left = await evalExpr(node.left, st);
+            return left ? await evalExpr(node.right, st) : left;
+        }
+        case '+': {
+            return evalBinOp(node, st, (l, r) => l + r);
+        }
+        case 'concat': {
+            return evalBinOp(node, st, (l, r) => l + '' + r);
+        }
+        case '-': {
+            return evalBinOp(node, st, (l, r) => l - r);
+        }
+        case '*': {
+            return evalBinOp(node, st, (l, r) => l * r);
+        }
+        case '/': {
+            return evalBinOp(node, st, (l, r) => l / r);
+        }
+        case '%': {
+            return evalBinOp(node, st, (l, r) => l % r);
+        }
+        default:
+            throw st.runtime.handleError(new Error(`Unknown binop ${op}`), node.lineno, node.colno);
+    }
+}
+async function evalUnaryOp(node, st, op) {
+    switch (op) {
+        case '!': {
+            const v = await evalExpr(node.target, st);
+            return !v;
+        }
+        case '+': {
+            const v = await evalExpr(node.target, st);
+            return +v;
+        }
+        case '-': {
+            const v = await evalExpr(node.target, st);
+            return -v;
+        }
+        default:
+            throw st.runtime.handleError(new Error(`Unknown unary ${op}`), node.lineno, node.colno);
+    }
+}
+async function evalNodeList(node, st) {
+    const out = [];
+    for (const child of node.children)
+        out.push(await evalExpr(child, st));
+    return out;
+}
+async function evalGroup(node, st) {
+    let last = undefined;
+    for (const child of node.children)
+        last = await evalExpr(child, st);
+    return last;
+}
+async function evalArrayNode(node, st) {
+    const arr = [];
+    for (const child of node.children)
+        arr.push(await evalExpr(child, st));
+    return arr;
+}
+async function evalDict(node, st) {
+    const obj = {};
+    for (const child of node.children) {
+        const pair = child;
+        const keyNode = pair.key;
+        let key;
+        if (keyNode instanceof nodes_1.Symbol)
+            key = keyNode.value;
+        else
+            key = await evalExpr(keyNode, st);
+        obj[String(key)] = await evalExpr(pair.value, st);
+    }
+    return obj;
+}
+async function evalKeywordArgs(node, st) {
+    const dict = await evalDict(node, st);
+    return st.runtime.makeKeywordArgs(dict);
+}
+function jsCompare(op, a, b) {
+    switch (op) {
+        case '==':
+            return a == b;
+        case '===':
+            return a === b;
+        case '!=':
+            return a != b;
+        case '!==':
+            return a !== b;
+        case '<':
+            return a < b;
+        case '>':
+            return a > b;
+        case '<=':
+            return a <= b;
+        case '>=':
+            return a >= b;
+        default:
+            throw new Error(`Unknown compare op: ${op}`);
+    }
+}
+async function evalCompare(node, st) {
+    let left = await evalExpr(node.expr, st);
+    for (const op of node.ops) {
+        const right = await evalExpr(op.expr, st);
+        if (!jsCompare(op.type, left, right))
+            return false;
+        left = right;
+    }
+    return true;
+}
+// Conditional
+async function evalIf(node, st) {
+    const cond = await evalExpr(node.cond, st);
+    if (cond)
+        return evalNode(node.body, st);
+    if (node.else_)
+        return evalNode(node.else_, st);
+}
+async function evalIfAsync(node, st) {
+    return evalIf(node, st);
+}
+async function evalSet(node, st) {
+    const targets = node.targets; // array of Symbol
+    let value;
+    if (node.value)
+        value = await evalExpr(node.value, st);
+    else {
+        const cap = { ...st, frame: st.frame.push(true), buffer: [] };
+        await evalNode(node.body, cap);
+        value = cap.buffer.join('');
+    }
+    for (const t of targets) {
+        const name = t.value;
+        st.frame.set(name, value, true);
+        if (st.frame.topLevel) {
+            st.context.setVariable(name, value);
+            if (!name.startsWith('_'))
+                st.context.addExport(name);
+        }
+    }
+}
+async function evalFor(node, st) {
+    const frame = st.frame.push();
+    const inner = { ...st, frame };
+    const iterVal = await evalExpr(node.arr, inner);
+    const arr = iterVal ? st.runtime.fromIterator(iterVal) : null;
+    let didIterate = false;
+    if (arr) {
+        if (node.name instanceof nodes_1.ArrayNode) {
+            const names = node.name.children.map((c) => c.value);
+            if (Array.isArray(arr)) {
+                for (let i = 0; i < arr.length; i++) {
+                    didIterate = true;
+                    const row = arr[i];
+                    const loopFrame = frame.push();
+                    const loopSt = { ...inner, frame: loopFrame };
+                    for (let u = 0; u < names.length; u++) {
+                        loopFrame.set(names[u], row?.[u]);
+                    }
+                    await evalNode(node.body, loopSt);
+                }
+            }
+            else {
+                let i = -1;
+                for (const key of Object.keys(arr)) {
+                    i++;
+                    didIterate = true;
+                    const loopFrame = frame.push();
+                    const loopSt = { ...inner, frame: loopFrame };
+                    const [keyName, valName] = names;
+                    loopFrame.set(keyName, key);
+                    loopFrame.set(valName, arr[key]);
+                    await evalNode(node.body, loopSt);
+                }
+            }
+        }
+        else {
+            const name = node.name.value; // Symbol
+            if (Array.isArray(arr)) {
+                for (let i = 0; i < arr.length; i++) {
+                    didIterate = true;
+                    const loopFrame = frame.push();
+                    const loopSt = { ...inner, frame: loopFrame };
+                    loopFrame.set(name, arr[i]);
+                    await evalNode(node.body, loopSt);
+                }
+            }
+            else {
+                // for (const k in arr) {
+                // 	didIterate = true;
+                // 	const loopFrame = frame.push();
+                // 	const loopSt: EvalState = { ...inner, frame: loopFrame };
+                // 	loopFrame.set(name, arr[k]);
+                // 	await evalNode(node.body, loopSt);
+                // }
+            }
+        }
+    }
+    if (!didIterate && node.else_) {
+        await evalNode(node.else_, inner);
+    }
+}
+async function evalCallExtension(node, st) {
+    const ext = st.env.getExtension(node.extname);
+    const fn = ext?.[node.prop];
+    if (typeof fn !== 'function') {
+        throw st.runtime.handleError(new Error(`Extension "${node.extname}" has no method "${node.prop}"`), node.lineno, node.colno);
+    }
+    const args = [];
+    if (node.args) {
+        for (const child of node.args.children)
+            args.push(await evalExpr(child, st));
+    }
+    const contentFns = [];
+    if (node.contentArgs?.length) {
+        for (const contentNode of node.contentArgs) {
+            if (!contentNode) {
+                contentFns.push(null);
+                continue;
+            }
+            contentFns.push(async () => {
+                const inner = {
+                    ...st,
+                    frame: st.frame.push(true),
+                    buffer: [],
+                };
+                await evalNode(contentNode, inner); // contentNode is likely NodeList/Output
+                return inner.buffer.join('');
+            });
+        }
+    }
+    const res = fn.call(ext, st.context, ...args, ...contentFns);
+    if (node instanceof nodes_1.CallExtensionAsync) {
+        return await new Promise((resolve, reject) => {
+            if (res && typeof res.then === 'function')
+                res.then(resolve, reject);
+            else
+                resolve(res);
+        });
+    }
+    return res;
+}
+async function evalExpr(node, st) {
+    // BinOp
+    if (node instanceof nodes_1.Or)
+        return evalBinOpHp(node, st, '||');
+    if (node instanceof nodes_1.And)
+        return evalBinOpHp(node, st, '&&');
+    if (node instanceof nodes_1.Concat)
+        return evalBinOpHp(node, st, 'concat');
+    if (node instanceof nodes_1.Add)
+        return evalBinOpHp(node, st, '+');
+    if (node instanceof nodes_1.Sub)
+        return evalBinOpHp(node, st, '-');
+    if (node instanceof nodes_1.Mul)
+        return evalBinOpHp(node, st, '*');
+    if (node instanceof nodes_1.Div)
+        return evalBinOpHp(node, st, '/');
+    if (node instanceof nodes_1.Mod)
+        return evalBinOpHp(node, st, '%');
+    // UnaryOp
+    if (node instanceof nodes_1.Pos)
+        return evalUnaryOp(node, st, '+');
+    if (node instanceof nodes_1.Neg)
+        return evalUnaryOp(node, st, '-');
+    if (node instanceof nodes_1.Not)
+        return evalUnaryOp(node, st, '!');
+    // List types
+    if (node instanceof nodes_1.NodeList)
+        return evalNodeList(node, st);
+    if (node instanceof nodes_1.Group)
+        return evalGroup(node, st);
+    if (node instanceof nodes_1.ArrayNode)
+        return evalArrayNode(node, st);
+    if (node instanceof nodes_1.Dict)
+        return evalDict(node, st);
+    if (node instanceof nodes_1.KeywordArgs)
+        return evalKeywordArgs(node, st);
+    if (node instanceof nodes_1.Compare)
+        return evalCompare(node, st);
+    if (node instanceof nodes_1.CallExtension)
+        return evalCallExtension(node, st);
+    if (node instanceof nodes_1.CallExtensionAsync)
+        return evalCallExtension(node, st);
+    if (node instanceof nodes_1.Literal)
+        return node.value;
+    if (node instanceof nodes_1.Symbol) {
+        const v = st.runtime.contextOrFrameLookup(st.context, st.frame, node.value);
+        lib_1.p.debug('LOOKUP', node.value, '=>', v);
+        return v;
+    }
+    if (node instanceof nodes_1.LookupVal) {
+        const target = await evalExpr(node.target, st);
+        const key = await evalExpr(node.val, st);
+        return st.runtime.memberLookup(target, key);
+    }
+    if (node instanceof nodes_1.Filter) {
+        const name = node.name.value; // your AST uses Symbol node for filter name
+        const fn = st.env.getFilter(name);
+        const args = [];
+        for (const child of node.args.children) {
+            args.push(await evalExpr(child, st));
+        }
+        return fn.call(st.context, ...args);
+    }
+    if (node instanceof nodes_1.FunCall) {
+        const callee = await evalExpr(node.name, st);
+        const args = [];
+        for (const child of node.args.children)
+            args.push(await evalExpr(child, st));
+        return st.runtime.callWrap(callee, 
+        /*friendlyName*/ '...', st.context, args);
+    }
+    if (node instanceof nodes_1.InlineIf) {
+        const cond = await evalExpr(node.cond, st);
+        if (cond)
+            return evalExpr(node.body, st);
+        return node.else_ ? evalExpr(node.else_, st) : '';
+    }
+    throw st.runtime.handleError(new Error(`evalExpr: unsupported node ${node.typename}`), node.lineno, node.colno);
+}
+function write(st, s) {
+    st.buffer.push(s);
+}
+async function evalOutput(node, st) {
+    for (const child of node.children) {
+        if (child instanceof nodes_1.TemplateData) {
+            if (child.value)
+                write(st, child.value);
+            continue;
+        }
+        const val = await evalExpr(child, st);
+        const safe = st.runtime.suppressValue(st.env.throwOnUndefined
+            ? st.runtime.ensureDefined(val, node.lineno, node.colno)
+            : val, st.env.autoescape);
+        write(st, safe);
+    }
+}
+async function evalNode(node, st) {
+    switch (node.typename) {
+        case 'Output':
+            return evalOutput(node, st);
+        case 'NodeList':
+            return evalNodeListStmt(node, st);
+        case 'If':
+            return evalIf(node, st);
+        case 'IfAsync':
+            return evalIfAsync(node, st);
+        case 'For':
+            return evalFor(node, st);
+        case 'Set':
+            return evalSet(node, st);
+        case 'Extends':
+            return evalExtends(node, st);
+        case 'Root':
+            return evalRoot(node, st);
+        case 'Block':
+            return evalBlock(node, st);
+        default:
+            throw st.runtime.handleError('Unknown evaluation: ' + node.typename);
+    }
+}
+async function renderRootToString(ast, st) {
+    const inner = { ...st, frame: st.frame, buffer: [] };
+    await evalNode(ast, inner);
+    return inner.buffer.join('');
+}
+async function renderAST(env, ast, ctx, runtime) {
+    lib_1.p.debug('ctx: ', ctx);
+    const context = new environment_1.Context(ctx || {}, /*blocks*/ {}, env);
+    const frame = new runtime_1.Frame();
+    frame.topLevel = true;
+    const st = { env, context, frame, runtime, buffer: [], rootAst: ast };
+    await evalNode(ast, st);
+    return st.buffer.join('');
+}
+// async function renderTemplate(tpl: Template, ctx: any) {
+//   const context = new Context(ctx, /*blocks*/ {}, tpl.env);
+//   const frame = new Frame(); frame.topLevel = true;
+//   // register our blocks first
+//   for (const [name, blockNode] of tpl.blocks) {
+//     context.addBlock(name, makeBlockFn(blockNode, tpl.env));
+//   }
+//   // if extends, load parent and render parent root
+//   if (tpl.parentName) {
+//     const parent = await tpl.env.getTemplate(tpl.parentName, /*eager*/ true, tpl.path, /*ignoreMissing*/ false);
+//     // parent will call context.getBlock("name") and it’ll resolve to overridden blocks
+//     return await renderRoot(parent, context, frame);
+//   }
+//   // otherwise render our root
+//   return await renderRoot(tpl, context, frame);
+// }
+// function makeBlockFn(blockBody: NodeList, env: Environment) {
+//   return async (context: Context, frame: Frame, runtime: Runtime) => {
+//     const st: EvalState = { env, context, frame: frame.push(true), runtime, buffer: [] };
+//     await evalNode(blockBody, st);
+//     return st.buffer.join("");
+//   };
+// }

package/dist/src/lexer.d.ts

@@ -0,0 +1,72 @@
+import { Token } from './types';
+export declare const whitespaceChars = " \n\t\r\u00A0";
+export declare const delimChars = "()[]{}%*-+~/#,:|.<>=!";
+export declare const intChars = "0123456789";
+export declare const BLOCK_START = "{%";
+export declare const BLOCK_END = "%}";
+export declare const VARIABLE_START = "{{";
+export declare const VARIABLE_END = "}}";
+export declare const COMMENT_START = "{#";
+export declare const COMMENT_END = "#}";
+export declare const TOKEN_STRING = "string";
+export declare const TOKEN_WHITESPACE = "whitespace";
+export declare const TOKEN_DATA = "data";
+export declare const TOKEN_BLOCK_START = "block-start";
+export declare const TOKEN_BLOCK_END = "block-end";
+export declare const TOKEN_VARIABLE_START = "variable-start";
+export declare const TOKEN_VARIABLE_END = "variable-end";
+export declare const TOKEN_COMMENT = "comment";
+export declare const TOKEN_LEFT_PAREN = "left-paren";
+export declare const TOKEN_RIGHT_PAREN = "right-paren";
+export declare const TOKEN_LEFT_BRACKET = "left-bracket";
+export declare const TOKEN_RIGHT_BRACKET = "right-bracket";
+export declare const TOKEN_LEFT_CURLY = "left-curly";
+export declare const TOKEN_RIGHT_CURLY = "right-curly";
+export declare const TOKEN_OPERATOR = "operator";
+export declare const TOKEN_COMMA = "comma";
+export declare const TOKEN_COLON = "colon";
+export declare const TOKEN_TILDE = "tilde";
+export declare const TOKEN_PIPE = "pipe";
+export declare const TOKEN_INT = "int";
+export declare const TOKEN_FLOAT = "float";
+export declare const TOKEN_BOOLEAN = "boolean";
+export declare const TOKEN_NONE = "none";
+export declare const TOKEN_SYMBOL = "symbol";
+export declare const TOKEN_SPECIAL = "special";
+export declare const TOKEN_REGEX = "regex";
+interface ITokenizerOpts {
+    trimBlocks?: boolean;
+    lstripBlocks?: boolean;
+    tags?: Record<string, any>;
+}
+export declare class Tokenizer {
+    str: string;
+    index: number;
+    len: number;
+    lineno: number;
+    colno: number;
+    inCode: boolean;
+    trimBlocks: boolean;
+    lstripBlocks: boolean;
+    tags: Record<string, any>;
+    src: any;
+    constructor(str: string, opts: ITokenizerOpts);
+    nextToken(): Token;
+    _parseString(delimiter: string): string;
+    _matches(str: string): boolean;
+    _extractString(str: string): string;
+    _extractUntil(charString: string): string;
+    _extract(charString: string): string;
+    _extractMatching(breakOnMatch: boolean, charString: string): string;
+    _extractRegex(regex: RegExp): RegExpMatchArray;
+    isFinished(): boolean;
+    forwardN(n: number): void;
+    forward(): void;
+    backN(n: number): void;
+    back(): void;
+    current(): string;
+    currentStr(): string;
+    previous(): string;
+}
+export declare const lex: (str: string, opts: ITokenizerOpts) => Tokenizer;
+export {};