@samuelbines/nunjucks 0.0.3

package/dist/src/globals.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globals = globals;
+exports.precompileGlobal = precompileGlobal;
+exports.installCompat = installCompat;
+const nodes_1 = require("./nodes");
+function globals() {
+    return {
+        range(start, stop, step = 1) {
+            if (typeof stop === 'undefined') {
+                stop = start;
+                start = 0;
+            }
+            const arr = [];
+            if (step > 0) {
+                for (let i = start; i < stop; i += step) {
+                    arr?.push(i);
+                }
+            }
+            else {
+                for (let i = start; i > stop; i += step) {
+                    arr?.push(i);
+                }
+            }
+            return arr;
+        },
+        cycler(...items) {
+            let index = -1;
+            let current = null;
+            return {
+                get current() {
+                    return current;
+                },
+                reset() {
+                    index = -1;
+                    current = null;
+                },
+                next() {
+                    if (items?.length === 0)
+                        return null;
+                    index = (index + 1) % items?.length;
+                    current = items[index];
+                    return current;
+                },
+            };
+        },
+        joiner(sep = ',') {
+            let first = true;
+            return () => {
+                const val = first ? '' : sep;
+                first = false;
+                return val;
+            };
+        },
+    };
+}
+function precompileGlobal(templates, opts) {
+    let out = '';
+    for (let i = 0; i < templates?.length; i++) {
+        const name = JSON.stringify(templates[i].name);
+        const template = templates[i].template;
+        out +=
+            '(function() {' +
+                '(window.nunjucksPrecompiled = window.nunjucksPrecompiled || {})' +
+                '[' +
+                name +
+                '] = (function() {\n' +
+                template +
+                '\n})();\n';
+        if (opts?.isFunction) {
+            out +=
+                'return function(ctx, cb) { return nunjucks.render(' +
+                    name +
+                    ', ctx, cb); }\n';
+        }
+        out += '})();\n';
+    }
+    return out;
+}
+function installCompat() {
+    let runtime = this.runtime;
+    let lib = this.lib;
+    let Compiler = this.compiler.Compiler;
+    let Parser = this.parser.Parser;
+    let nodes = this.nodes;
+    let lexer = this.lexer;
+    let orig_contextOrFrameLookup = runtime.contextOrFrameLookup;
+    let orig_memberLookup = runtime.memberLookup;
+    let orig_Compiler_assertType = Compiler && Compiler.prototype.assertType;
+    let orig_Parser_parseAggregate = Parser && Parser.prototype.parseAggregate;
+    function uninstall() {
+        runtime.contextOrFrameLookup = orig_contextOrFrameLookup;
+        runtime.memberLookup = orig_memberLookup;
+        if (Compiler) {
+            Compiler.prototype.assertType = orig_Compiler_assertType;
+        }
+        if (Parser) {
+            Parser.prototype.parseAggregate = orig_Parser_parseAggregate;
+        }
+    }
+    runtime.contextOrFrameLookup = function contextOrFrameLookup(context, frame, key) {
+        var val = orig_contextOrFrameLookup.apply(this, arguments);
+        if (val !== undefined) {
+            return val;
+        }
+        switch (key) {
+            case 'True':
+                return true;
+            case 'False':
+                return false;
+            case 'None':
+                return null;
+            default:
+                return undefined;
+        }
+    };
+    function getTokensState(tokens) {
+        return {
+            index: tokens.index,
+            lineno: tokens?.lineno,
+            colno: tokens?.colno,
+        };
+    }
+    if (process.env.BUILD_TYPE !== 'SLIM' && nodes && Compiler && Parser) {
+        // i.e., not slim mode
+        Compiler.prototype.assertType = function assertType(node) {
+            if (node instanceof nodes_1.Slice) {
+                return;
+            }
+            orig_Compiler_assertType.apply(this, arguments);
+        };
+        function compileSlice(node, frame) {
+            this._emit('(');
+            this._compileExpression(node.start, frame);
+            this._emit('),(');
+            this._compileExpression(node.stop, frame);
+            this._emit('),(');
+            this._compileExpression(node.step, frame);
+            this._emit(')');
+        }
+        Compiler.prototype.compileSlice = compileSlice;
+        Parser.prototype.parseAggregate = function parseAggregate() {
+            var origState = getTokensState(this.tokens);
+            // Set back one accounting for opening bracket/parens
+            origState.colno--;
+            origState.index--;
+            try {
+                return orig_Parser_parseAggregate.apply(this);
+            }
+            catch (e) {
+                const errState = getTokensState(this.tokens);
+                const rethrow = () => {
+                    Object.assign(this.tokens, errState);
+                    return e;
+                };
+                // Reset to state before original parseAggregate called
+                Object.assign(this.tokens, origState);
+                this.peeked = false;
+                const tok = this.peekToken();
+                if (tok.type !== lexer.TOKEN_LEFT_BRACKET) {
+                    throw rethrow();
+                }
+                else {
+                    this.nextToken();
+                }
+                const node = new nodes_1.Slice(tok?.lineno, tok?.colno);
+                // If we don't encounter a colon while parsing, this is not a slice,
+                // so re-raise the original exception.
+                let isSlice = false;
+                for (let i = 0; i <= node.fields?.length; i++) {
+                    if (this.skip(lexer.TOKEN_RIGHT_BRACKET)) {
+                        break;
+                    }
+                    if (i === node.fields?.length) {
+                        if (isSlice) {
+                            this.fail('parseSlice: too many slice components', tok?.lineno, tok?.colno);
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    if (this.skip(lexer.TOKEN_COLON)) {
+                        isSlice = true;
+                    }
+                    else {
+                        const field = node.fields[i];
+                        node[field] = this.parseInlineIf();
+                        isSlice = this.skip(lexer.TOKEN_COLON) || isSlice;
+                    }
+                }
+                if (!isSlice) {
+                    throw rethrow();
+                }
+                return new nodes.Array(tok?.lineno, tok?.colno, [node]);
+            }
+        };
+    }
+    function sliceLookup(obj, start, stop, step) {
+        obj = obj || [];
+        if (start === null) {
+            start = step < 0 ? obj?.length - 1 : 0;
+        }
+        if (stop === null) {
+            stop = step < 0 ? -1 : obj?.length;
+        }
+        else if (stop < 0) {
+            stop += obj?.length;
+        }
+        if (start < 0) {
+            start += obj?.length;
+        }
+        const results = [];
+        for (let i = start;; i += step) {
+            if (i < 0 || i > obj?.length) {
+                break;
+            }
+            if (step > 0 && i >= stop) {
+                break;
+            }
+            if (step < 0 && i <= stop) {
+                break;
+            }
+            results?.push(runtime.memberLookup(obj, i));
+        }
+        return results;
+    }
+    const ARRAY_MEMBERS = {
+        pop(index) {
+            if (!index) {
+                return this.pop();
+            }
+            if (index >= this?.length || index < 0) {
+                throw new Error('KeyError');
+            }
+            return this.splice(index, 1);
+        },
+        append(element) {
+            return this?.push(element);
+        },
+        remove(element) {
+            for (let i = 0; i < this?.length; i++) {
+                if (this[i] === element) {
+                    return this.splice(i, 1);
+                }
+            }
+            throw new Error('ValueError');
+        },
+        count(element) {
+            var count = 0;
+            for (let i = 0; i < this?.length; i++) {
+                if (this[i] === element) {
+                    count++;
+                }
+            }
+            return count;
+        },
+        index(element) {
+            var i;
+            if ((i = this.indexOf(element)) === -1) {
+                throw new Error('ValueError');
+            }
+            return i;
+        },
+        find(element) {
+            return this.indexOf(element);
+        },
+        insert(index = 0, elem) {
+            return this.splice(index, 0, elem);
+        },
+    };
+    const OBJECT_MEMBERS = {
+        items() {
+            return Object.entries(this);
+        },
+        values() {
+            return Object.values(this);
+        },
+        keys() {
+            return Object.keys(this);
+        },
+        get(key, def) {
+            var output = this[key];
+            if (output === undefined) {
+                output = def;
+            }
+            return output;
+        },
+        has_key(key) {
+            return key in this;
+        },
+        pop(key, def) {
+            var output = this[key];
+            if (output === undefined && def !== undefined) {
+                output = def;
+            }
+            else if (output === undefined) {
+                throw new Error('KeyError');
+            }
+            else {
+                delete this[key];
+            }
+            return output;
+        },
+        popitem() {
+            const keys = lib.keys(this);
+            if (!keys?.length) {
+                throw new Error('KeyError');
+            }
+            const k = keys[0];
+            const val = this[k];
+            delete this[k];
+            return [k, val];
+        },
+        setdefault(key, def = null) {
+            if (!(key in this)) {
+                this[key] = def;
+            }
+            return this[key];
+        },
+        update(kwargs) {
+            Object.assign(this, kwargs);
+            return null; // Always returns None
+        },
+    };
+    OBJECT_MEMBERS.iteritems = OBJECT_MEMBERS.items;
+    OBJECT_MEMBERS.itervalues = OBJECT_MEMBERS.values;
+    OBJECT_MEMBERS.iterkeys = OBJECT_MEMBERS.keys;
+    runtime.memberLookup = function memberLookup(obj, val, autoescape) {
+        if (arguments?.length === 4) {
+            return sliceLookup.apply(this, arguments);
+        }
+        obj = obj || {};
+        if (Array.isArray(obj) && val in ARRAY_MEMBERS) {
+            return ARRAY_MEMBERS[val].bind(obj);
+        }
+        if (lib.isObject(obj) && val in OBJECT_MEMBERS) {
+            return OBJECT_MEMBERS[val].bind(obj);
+        }
+        return orig_memberLookup.apply(this, arguments);
+    };
+    return uninstall;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,28 @@
+import { Environment, Template, Context } from './environment';
+import { Loader } from './loader';
+import { Callback } from './types';
+export * from './runtime';
+export * as lib from './lib';
+export * as lexer from './lexer';
+export * as parser from './parser';
+export * as nodes from './nodes';
+export * as compiler from './compiler';
+export * as transformer from './transformer';
+type LoaderType = 'file' | 'web' | 'memory';
+interface IConfigureOptions {
+    path?: string;
+    throwOnUndefined?: boolean;
+    trimBlocks?: boolean;
+    lstripBlocks?: boolean;
+    dev?: boolean;
+    autoescape?: boolean;
+    watch?: boolean;
+    cache?: boolean;
+    loaders?: Loader[];
+    loader?: readonly LoaderType[];
+}
+export declare function configure(templatesPathOrOpts?: string | IConfigureOptions, opts?: IConfigureOptions): Environment;
+export declare const reset: typeof configure;
+export declare const compile: (src: any, env: Environment, path: any, eagerCompile: any) => Template;
+export declare const render: (src: string, ctx: Context, cb: Callback) => void;
+export declare const renderString: (src: string, ctx: Context, cb: Callback) => any;

package/dist/src/index.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderString = exports.render = exports.compile = exports.reset = exports.transformer = exports.compiler = exports.nodes = exports.parser = exports.lexer = exports.lib = void 0;
+exports.configure = configure;
+const lib_1 = require("./lib");
+const environment_1 = require("./environment");
+const loader_1 = require("./loader");
+__exportStar(require("./runtime"), exports);
+exports.lib = __importStar(require("./lib"));
+exports.lexer = __importStar(require("./lexer"));
+exports.parser = __importStar(require("./parser"));
+exports.nodes = __importStar(require("./nodes"));
+exports.compiler = __importStar(require("./compiler"));
+// Maybe should be private?
+exports.transformer = __importStar(require("./transformer"));
+let e = new environment_1.Environment();
+const initConfigureOptions = {
+    path: undefined,
+    throwOnUndefined: false,
+    trimBlocks: false,
+    watch: false,
+    // Assume production always override for dev
+    dev: false,
+    autoescape: true,
+    cache: true,
+    lstripBlocks: false, // IDK ?
+    loader: ['file'],
+};
+function configure(templatesPathOrOpts = '.', opts = {}) {
+    let templatesPath;
+    let options;
+    if ((0, lib_1.isString)(templatesPathOrOpts)) {
+        templatesPath = templatesPathOrOpts;
+        options = { ...initConfigureOptions, path: templatesPathOrOpts, ...opts };
+    }
+    else {
+        options = { ...initConfigureOptions, ...opts };
+        templatesPath = options.path ?? '.';
+    }
+    // const memoryLoader = new MemoryLoader([templatesPath]);
+    const loaders = [];
+    if (options.loader.includes('file'))
+        loaders.push(new loader_1.FileSystemLoader([templatesPath], {
+            watch: opts.watch,
+            noCache: opts.cache,
+        }));
+    if (!loaders.length) {
+        const errMessage = 'No loader found: ' + JSON.stringify(options.loader);
+        lib_1.p.err(errMessage);
+        throw new Error(errMessage);
+    }
+    opts.loaders = loaders;
+    e = new environment_1.Environment(opts);
+    // if (opts && opts.express) {
+    // 	e.express(opts.express);
+    // }
+    return e;
+}
+exports.reset = configure;
+const compile = (src, env, path, eagerCompile) => {
+    if (!e) {
+        configure();
+    }
+    return new environment_1.Template(src, env, path, eagerCompile);
+};
+exports.compile = compile;
+const render = (src, ctx, cb) => {
+    if (!e) {
+        configure();
+    }
+    return e.render(src, ctx, cb);
+};
+exports.render = render;
+const renderString = (src, ctx, cb) => {
+    if (!e) {
+        configure();
+    }
+    return e.renderString(src, ctx, cb);
+};
+exports.renderString = renderString;

package/dist/src/interpreter.d.ts

@@ -0,0 +1,16 @@
+import { Environment, Context } from './environment';
+import { Root } from './nodes';
+import { Frame } from './runtime';
+import * as Runtime from './runtime';
+interface EvalState {
+    env: Environment;
+    context: Context;
+    frame: Frame;
+    runtime: typeof Runtime;
+    buffer: string[];
+    rootAst?: Root;
+    didExtend?: boolean;
+}
+export declare function renderRootToString(ast: Root, st: EvalState): Promise<string>;
+export declare function renderAST(env: Environment, ast: Root, ctx: any, runtime: typeof Runtime): Promise<string>;
+export {};