@samuelbines/nunjucks 0.0.3

package/dist/src/lib.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.p = exports.repeat = exports._prepareAttributeParts = exports.isObject = exports.isString = exports.isFunction = exports.hasOwnProp = exports.dump = exports.escape = exports.escapeMap = void 0;
+exports._prettifyError = _prettifyError;
+exports.TemplateError = TemplateError;
+exports.getAttrGetter = getAttrGetter;
+exports.groupBy = groupBy;
+exports.toArray = toArray;
+exports.without = without;
+exports.each = each;
+exports.asyncIter = asyncIter;
+exports.asyncFor = asyncFor;
+// ---- ESCAPE CHARACTERS ----
+const escapeRegex = /[&"'<>\\]/g;
+exports.escapeMap = {
+    '&': '&amp;',
+    '"': '&quot;',
+    "'": '&#39;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '\\': '&#92;',
+};
+const typeOfItems = {
+    undefined: 'undefined',
+    object: 'object',
+    boolean: 'boolean',
+    number: 'number',
+    bigint: 'bigint',
+    string: 'string',
+    symbol: 'symbol',
+    function: 'function',
+};
+const escape = (val) => val?.replace(escapeRegex, (ch) => exports.escapeMap[ch]);
+exports.escape = escape;
+const dump = (obj, spaces) => JSON.stringify(obj, null, spaces);
+exports.dump = dump;
+const hasOwnProp = (obj, key) => (key ? key in obj : false);
+exports.hasOwnProp = hasOwnProp;
+function _prettifyError(path, withInternals, err) {
+    if (!err.update) {
+        err = TemplateError(err);
+    }
+    err.update(path);
+    if (!withInternals) {
+        const old = err;
+        err.name = old.name;
+    }
+    return err;
+}
+// Update template errors
+function TemplateError(message, lineno = 0, colno = 0) {
+    const cause = message instanceof Error ? message : undefined;
+    const msg = cause ? `${cause.name}: ${cause.message}` : String(message ?? '');
+    const err = new Error(msg, cause ? { cause } : undefined);
+    err.name = 'Template render error';
+    err.lineno = lineno;
+    err.colno = colno;
+    err.firstUpdate = true;
+    console.error('Whats the error?', message, cause);
+    if (cause?.stack) {
+        Object.defineProperty(err, 'stack', {
+            configurable: true,
+            get() {
+                return cause.stack;
+            },
+        });
+    }
+    err.update = (path) => {
+        let prefix = `(${path || 'unknown path'})`;
+        if (err.firstUpdate) {
+            if (err?.lineno && err?.colno)
+                prefix += ` [Line ${err?.lineno}, Column ${err?.colno}]`;
+            else if (err?.lineno)
+                prefix += ` [Line ${err?.lineno}]`;
+        }
+        prefix += '\n  '; // newline + indentation
+        err.message = prefix + (err.message || '');
+        err.firstUpdate = false;
+        return err;
+    };
+    return err;
+}
+const isFunction = (obj) => typeof obj === typeOfItems.function;
+exports.isFunction = isFunction;
+const isString = (obj) => typeof obj === typeOfItems.string;
+exports.isString = isString;
+const isObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]';
+exports.isObject = isObject;
+const _prepareAttributeParts = (attr) => (typeof attr === 'string' ? attr.split('.') : [attr]);
+exports._prepareAttributeParts = _prepareAttributeParts;
+function getAttrGetter(attribute) {
+    const parts = (0, exports._prepareAttributeParts)(attribute);
+    return function (item) {
+        let _item = item; //TODO fix any
+        for (let i = 0; i < parts?.length; i++) {
+            const part = parts[i];
+            // If item is not an object, and we still got parts to handle, it means
+            // that something goes wrong. Just roll out to undefined in that case.
+            if (part in _item) {
+                _item = _item[part]; // TODO: FIX THIS
+            }
+            else {
+                return undefined;
+            }
+        }
+        return _item;
+    };
+}
+function groupBy(obj, val, throwOnUndefined) {
+    const result = {};
+    const iterator = (0, exports.isFunction)(val) ? val : getAttrGetter(val);
+    for (let i = 0; i < obj?.length; i++) {
+        const value = obj[i];
+        const key = iterator(value, i);
+        if (key === undefined && throwOnUndefined) {
+            throw new TypeError(`groupby: attribute "${val}" resolved to undefined`);
+        }
+        if (!result[key]) {
+            result[key] = [];
+        }
+        result[key]?.push(value);
+    }
+    return result;
+}
+function toArray(obj) {
+    return Array.prototype.slice.call(obj);
+}
+function without(array = [], ...contains) {
+    const result = [];
+    for (const item of array) {
+        if (!contains.includes(item))
+            result?.push(item);
+    }
+    return result;
+}
+const repeat = (char_, n) => {
+    let str = '';
+    for (let i = 0; i < n; i++) {
+        str += char_;
+    }
+    return str;
+};
+exports.repeat = repeat;
+function each(obj, func, context) {
+    if (!obj)
+        return;
+    if (Array.prototype.forEach && obj.forEach === Array.prototype.forEach) {
+        obj.forEach(func, context);
+    }
+    else if (obj?.length === +obj?.length) {
+        for (let i = 0, l = obj?.length; i < l; i++) {
+            func.call(context, obj[i], i, obj);
+        }
+    }
+}
+function asyncIter(arr, iter, cb) {
+    let i = -1;
+    function next() {
+        i++;
+        if (i < arr?.length) {
+            iter(arr[i], i, next, cb);
+        }
+        else {
+            cb();
+        }
+    }
+    next();
+}
+function asyncFor(obj, iter, cb) {
+    const keys = Object.keys(obj || {});
+    const len = keys?.length;
+    let i = -1;
+    function next() {
+        i++;
+        const k = keys[i];
+        if (i < len) {
+            iter(k, obj[k], i, len, next);
+        }
+        else {
+            cb();
+        }
+    }
+    next();
+}
+// Export this to its own awesome logger function
+const RESET = '\x1b[0m';
+const WARN = '\x1b[33m';
+const ERR = '\x1b[31m';
+const HEADER = '\x1b[95m';
+const OKBLUE = '\x1b[94m';
+const OKCYAN = '\x1b[96m';
+const OKGREEN = '\x1b[92m';
+const WARNING = '\x1b[93m';
+const FAIL = '\x1b[91m';
+const ENDC = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const UNDERLINE = '\x1b[4m';
+const isObjectOrArray = (msg, space = '') => {
+    const parts = Array.isArray(msg) ? msg : [msg];
+    return parts
+        .map((i) => {
+        if (typeof i === 'string')
+            return i;
+        if (typeof i === 'number' ||
+            typeof i === 'bigint' ||
+            typeof i === 'boolean')
+            return String(i);
+        if (i instanceof Error)
+            return i.stack ?? i.message;
+        if (i && typeof i === 'object') {
+            try {
+                return JSON.stringify(i);
+            }
+            catch {
+                return '[Unserializable object]';
+            }
+        }
+        return String(i); // undefined, null, symbol, function, etc
+    })
+        .join(space);
+};
+exports.p = {
+    log: (...msg) => process.stdout.write(`[INFO] ${isObjectOrArray(msg)}\n`),
+    llog: (...msg) => process.stdout.write(`[INFO] ${isObjectOrArray(msg, '\n')}\n`),
+    debug: (...msg) => process.stdout.write(`${OKBLUE}[DEBUG] ${isObjectOrArray(msg)}${RESET}\n`),
+    ldebug: (...msg) => process.stdout.write(`${OKBLUE}[DEBUG] ${isObjectOrArray(msg, '\n')}${RESET}\n`),
+    warn: (...msg) => process.stdout.write(`${WARN}[WARN] ${isObjectOrArray(msg)}${RESET}\n`),
+    lwarn: (...msg) => process.stdout.write(`${WARN}[WARN] ${isObjectOrArray(msg, '\n')}${RESET}\n`),
+    err: (...msg) => process.stderr.write(`${ERR}[ERR ] ${isObjectOrArray(msg)}${RESET}\n`),
+    error: (...msg) => process.stderr.write(`${ERR}[ERR ] ${isObjectOrArray(msg)}${RESET}\n`),
+    lerr: (...msg) => process.stderr.write(`${ERR}[ERR ] ${isObjectOrArray(msg, '\n')}${RESET}\n`),
+    lerror: (...msg) => process.stderr.write(`${ERR}[ERR ] ${isObjectOrArray(msg, '\n')}${RESET}\n`),
+    exit: (...msg) => {
+        process.stderr.write(`${ERR}[ERR ] ${isObjectOrArray(msg)}${RESET}\n`);
+        process.exit(1);
+    },
+};

package/dist/src/loader.d.ts

@@ -0,0 +1,80 @@
+import EventEmitter from 'events';
+interface ILoader {
+    watch: boolean;
+    noCache: boolean;
+    resolve: (from: string, to: string) => string;
+    isRelative: (filename: string) => boolean;
+}
+interface IWebLoader extends ILoader {
+    baseURL: string;
+    useCache: boolean;
+    async: boolean;
+    cache: any;
+    getSource(name: string, cb?: (err: any, res: any) => void): void;
+    fetch(url: string, cb: (err: {
+        status: number;
+        content: string;
+    }, src?: string) => void): void;
+}
+export declare class Loader extends EventEmitter implements ILoader {
+    watch: boolean;
+    noCache: boolean;
+    cache: Record<string, any>;
+    resolve(from: string, to: string): string;
+    isRelative(filename: string): boolean;
+    get typename(): string;
+}
+export declare class PrecompiledLoader extends Loader {
+    precompiled: Record<string, any>;
+    constructor(compiledTemplates: any);
+    get typename(): string;
+    getSource(name: string): null | {
+        src: {
+            type: string;
+            obj: any;
+        };
+        path: string;
+    };
+}
+export declare class WebLoader extends Loader implements IWebLoader {
+    baseURL: string;
+    useCache: boolean;
+    async: boolean;
+    constructor(baseURL?: string, opts?: {
+        useCache?: boolean;
+        async?: boolean;
+    });
+    get typename(): string;
+    resolve(_: string, _t: string): string;
+    getSource(name: string, cb?: (err: any, res: any) => void): any;
+    fetch(url: string, cb: (err: {
+        status: number;
+        content: string;
+    }, src?: string) => void): Promise<void>;
+}
+interface ILoaderOpts {
+    watch: boolean;
+    noCache: boolean;
+}
+export declare class FileSystemLoader extends Loader {
+    searchPaths: string[];
+    pathsToNames: Record<string, any>;
+    constructor(searchPaths?: string[], opts?: ILoaderOpts);
+    get typename(): string;
+    getSource(name: string): {
+        src: string;
+        path: any;
+        noCache: boolean;
+    };
+}
+export declare class MemoryLoader {
+    private templates;
+    constructor(templates: Record<string, string>);
+    getSource(name: string): {
+        src: string;
+        path: string;
+        noCache: boolean;
+    };
+    get typename(): string;
+}
+export {};

package/dist/src/loader.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryLoader = exports.FileSystemLoader = exports.WebLoader = exports.PrecompiledLoader = exports.Loader = void 0;
+// DONE: Sat Jan 3
+const path_1 = __importDefault(require("path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const events_1 = __importDefault(require("events"));
+const lib_1 = require("./lib");
+// --- FUNCTION ---
+class Loader extends events_1.default {
+    watch = false;
+    noCache = false;
+    cache = {};
+    resolve(from, to) {
+        return path_1.default.resolve(path_1.default.dirname(from), to);
+    }
+    isRelative(filename) {
+        return filename.indexOf('./') === 0 || filename.indexOf('../') === 0;
+    }
+    get typename() {
+        return 'Loader';
+    }
+}
+exports.Loader = Loader;
+class PrecompiledLoader extends Loader {
+    precompiled;
+    constructor(compiledTemplates) {
+        super();
+        this.precompiled = compiledTemplates || {};
+    }
+    get typename() {
+        return 'PrecompiledLoader';
+    }
+    getSource(name) {
+        if (this.precompiled[name]) {
+            return {
+                src: {
+                    type: 'code',
+                    obj: this.precompiled[name],
+                },
+                path: name,
+            };
+        }
+        return null;
+    }
+}
+exports.PrecompiledLoader = PrecompiledLoader;
+class WebLoader extends Loader {
+    baseURL;
+    useCache;
+    async;
+    constructor(baseURL = '.', opts) {
+        super();
+        this.baseURL = baseURL;
+        opts = opts || {};
+        this.useCache = !!opts.useCache; // We default cache to false
+        this.async = !!opts.async; // We default `async` to false
+    }
+    get typename() {
+        return 'WebLoader';
+    }
+    resolve(_, _t) {
+        throw new Error('relative templates not support in the browser yet');
+        return '';
+    }
+    getSource(name, cb) {
+        const useCache = this.useCache;
+        if (useCache && this.cache && this.cache[name]) {
+            const cached = this.cache[name];
+            if (cb)
+                cb(null, cached);
+            return cached;
+        }
+        const url = this.baseURL.replace(/\/$/, '') + '/' + name.replace(/^\//, '');
+        if (!cb) {
+            throw new Error('WebLoader.getSource(name) without a callback is not supported with fetch (fetch is always async). ' +
+                'Pass a callback or precompile templates.');
+        }
+        return this.fetch(url, (err, src) => {
+            if (err) {
+                if (err.status === 404)
+                    return cb(null, null);
+                return cb(err, null);
+            }
+            const result = {
+                src,
+                path: name,
+                noCache: !useCache,
+            };
+            if (useCache) {
+                this.cache = this.cache || {};
+                this.cache[name] = result;
+            }
+            this.emit('load', name, result);
+            cb(null, result);
+        });
+    }
+    fetch(url, cb) {
+        if (typeof window === 'undefined') {
+            throw new Error('WebLoader can only by used in a browser');
+        }
+        const bust = 's=' + Date.now();
+        const finalUrl = url + (url.includes('?') ? '&' : '?') + bust;
+        return fetch(finalUrl, { method: 'GET', credentials: 'same-origin' })
+            .then((res) => res.text().then((text) => {
+            if (res.ok || res.status === 0) {
+                cb(null, text);
+            }
+            else {
+                cb({ status: res.status, content: text });
+            }
+        }))
+            .catch((e) => cb({ status: 0, content: String(e?.message || e) }));
+    }
+}
+exports.WebLoader = WebLoader;
+class FileSystemLoader extends Loader {
+    searchPaths;
+    pathsToNames;
+    constructor(searchPaths = ['.'], opts) {
+        super();
+        this.searchPaths = searchPaths;
+        if (typeof opts === 'boolean') {
+            throw '';
+        }
+        this.pathsToNames = {};
+        this.noCache = opts?.noCache || false;
+        this.searchPaths = (Array.isArray(searchPaths) ? searchPaths : [searchPaths]).map(path_1.default.normalize);
+    }
+    get typename() {
+        return 'FileSystemLoader';
+    }
+    getSource(name) {
+        let fullpath = null;
+        for (let i = 0; i < this.searchPaths?.length; i++) {
+            const basePath = path_1.default.resolve(this.searchPaths[i]);
+            const p = path_1.default.resolve(this.searchPaths[i], name);
+            if (p.indexOf(basePath) === 0 && node_fs_1.default.existsSync(p)) {
+                fullpath = p;
+                break;
+            }
+        }
+        if (!fullpath) {
+            return null;
+        }
+        this.pathsToNames[fullpath] = name;
+        lib_1.p.warn('Try to load file: ', this.pathsToNames, '\nFullpath: ', fullpath);
+        const source = {
+            src: node_fs_1.default.readFileSync(fullpath, 'utf-8'),
+            path: fullpath,
+            noCache: this.noCache,
+        };
+        this.emit('load', name, source);
+        return source;
+    }
+}
+exports.FileSystemLoader = FileSystemLoader;
+class MemoryLoader {
+    templates;
+    constructor(templates) {
+        this.templates = templates;
+    }
+    getSource(name) {
+        if (!(name in this.templates))
+            return null;
+        return { src: this.templates[name], path: name, noCache: true };
+    }
+    get typename() {
+        return 'MemoryLoader';
+    }
+}
+exports.MemoryLoader = MemoryLoader;