mancha 0.5.0 → 0.5.1

package/dist/core.js

@@ -9,16 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IRenderer = exports.safeEval = exports.extractTextNodeKeys = exports.resolvePath = exports.folderPath = exports.traverse = void 0;
-const path = require("path-browserify");
+exports.IRenderer = exports.safeEval = exports.isRelativePath = exports.dirname = exports.traverse = void 0;
 const reactive_1 = require("./reactive");
-const attributes_1 = require("./attributes");
-const KW_ATTRIBUTES = new Set([":bind", ":bind-events", ":data", ":for", ":show", "@watch"]);
-const ATTR_SHORTHANDS = {
-    // ":class": ":class-name",
-    $text: "$text-content",
-    $html: "$inner-HTML",
-};
+const iterator_1 = require("./iterator");
+const plugins_1 = require("./plugins");
 function* traverse(root, skip = new Set()) {
     const explored = new Set();
     const frontier = Array.from(root.childNodes).filter((node) => !skip.has(node));
@@ -38,434 +32,131 @@ function* traverse(root, skip = new Set()) {
     }
 }
 exports.traverse = traverse;
-function folderPath(fpath) {
-    if (fpath.endsWith("/")) {
-        return fpath.slice(0, -1);
-    }
-    else {
-        return path.dirname(fpath);
-    }
-}
-exports.folderPath = folderPath;
-function resolvePath(fpath) {
-    if (fpath.includes("://")) {
-        const [scheme, remotePath] = fpath.split("://", 2);
-        return `${scheme}://${resolvePath("/" + remotePath).substring(1)}`;
+function dirname(fpath) {
+    if (!fpath.includes("/")) {
+        return "";
     }
     else {
-        return path.resolve(fpath);
+        return fpath.split("/").slice(0, -1).join("/");
     }
 }
-exports.resolvePath = resolvePath;
-function extractTextNodeKeys(content) {
-    const matcher = new RegExp(/{{ ([\w\.]+) }}/gm);
-    return Array.from(content.matchAll(matcher)).map((match) => {
-        const orig = match[0];
-        let key = match[1];
-        const props = [];
-        if (key.includes(".")) {
-            const parts = key.split(".");
-            key = parts[0];
-            props.push(...parts.slice(1));
-        }
-        return [orig, key, props];
-    });
+exports.dirname = dirname;
+function isRelativePath(fpath) {
+    return (!fpath.includes("://") &&
+        !fpath.startsWith("/") &&
+        !fpath.startsWith("#") &&
+        !fpath.startsWith("data:"));
 }
-exports.extractTextNodeKeys = extractTextNodeKeys;
+exports.isRelativePath = isRelativePath;
 function safeEval(code, context, args = {}) {
     const inner = `with (this) { return (async () => (${code}))(); }`;
     return new Function(...Object.keys(args), inner).call(context, ...Object.values(args));
 }
 exports.safeEval = safeEval;
-const _DEFAULT_RENDERER_PARAMS = { maxdepth: 10 };
 class IRenderer extends reactive_1.ReactiveProxyStore {
     constructor() {
         super(...arguments);
-        this.fsroot = ".";
+        this.dirpath = "";
         this.skipNodes = new Set();
     }
-    clone() {
-        return new this.constructor(Object.fromEntries(this.store.entries()));
-    }
-    log(params, ...args) {
-        if (params === null || params === void 0 ? void 0 : params.debug)
-            console.debug(...args);
-    }
-    eval(expr_1) {
-        return __awaiter(this, arguments, void 0, function* (expr, args = {}, params) {
-            const proxy = (0, reactive_1.proxify)(this);
-            const result = yield safeEval(expr, proxy, Object.assign({}, args));
-            this.log(params, `eval \`${expr}\` => `, result);
-            return result;
-        });
-    }
-    resolveIncludes(root, params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            params = Object.assign({ fsroot: this.fsroot }, _DEFAULT_RENDERER_PARAMS, params);
-            const includes = Array.from(traverse(root, this.skipNodes))
-                .map((node) => node)
-                .filter((node) => { var _a; return ((_a = node.tagName) === null || _a === void 0 ? void 0 : _a.toLocaleLowerCase()) === "include"; })
-                .map((node) => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b;
-                const src = (_a = node.getAttribute) === null || _a === void 0 ? void 0 : _a.call(node, "src");
-                const dataset = Object.assign({}, node.dataset);
-                // Add all the data-* attributes as properties to current context.
-                // NOTE: this will propagate to all subsequent render calls, including nested calls.
-                Object.entries(dataset).forEach(([key, attr]) => this.set(key, (0, attributes_1.decodeHtmlAttrib)(attr)));
-                // Early exit: <include> tags must have a src attribute.
-                if (!src) {
-                    throw new Error(`"src" attribute missing from ${node}.`);
-                }
-                // The included file will replace this tag.
-                const handler = (fragment) => {
-                    node.replaceWith(...Array.from(fragment.childNodes));
-                };
-                // Decrement the maxdepth param.
-                params.maxdepth--;
-                // Case 1: Absolute remote path.
-                if (src.indexOf("://") !== -1) {
-                    yield this.renderRemotePath(src, Object.assign(Object.assign({}, params), { isRoot: false })).then(handler);
-                    // Case 2: Relative remote path.
-                }
-                else if (((_b = params.fsroot) === null || _b === void 0 ? void 0 : _b.indexOf("://")) !== -1) {
-                    const relpath = `${params.fsroot}/${src}`;
-                    yield this.renderRemotePath(relpath, Object.assign(Object.assign({}, params), { isRoot: false })).then(handler);
-                    // Case 3: Local absolute path.
-                }
-                else if (src.charAt(0) === "/") {
-                    yield this.renderLocalPath(src, Object.assign(Object.assign({}, params), { isRoot: false })).then(handler);
-                    // Case 4: Local relative path.
-                }
-                else {
-                    const relpath = path.join(params.fsroot, src);
-                    yield this.renderLocalPath(relpath, Object.assign(Object.assign({}, params), { isRoot: false })).then(handler);
-                }
-            }));
-            // Wait for all the rendering operations to complete.
-            yield Promise.all(includes);
-            // Re-render until no changes are made.
-            if (includes.length === 0) {
-                return this;
-            }
-            else if (params.maxdepth === 0) {
-                throw new Error("Maximum recursion depth reached.");
-            }
-            else {
-                return this.resolveIncludes(root, {
-                    fsroot: params.fsroot,
-                    maxdepth: params.maxdepth - 1,
-                });
-            }
-        });
-    }
-    resolveTextNode(node, params) {
-        if (node.nodeType !== 3)
-            return [];
-        const content = node.nodeValue || "";
-        // Identify all the context variables found in the content.
-        const keys = extractTextNodeKeys(content).filter(([, key]) => this.store.has(key));
-        // Early exit: no keys found in content.
-        if (keys.length === 0)
-            return [];
-        this.log(params, keys, "keys found in node:", node);
-        // Apply the context variables to the content, iteratively.
-        const updateNode = () => {
-            let updatedContent = content;
-            keys.forEach(([match, key, props]) => {
-                var _a;
-                updatedContent = updatedContent.replace(match, String((_a = this.get(key, ...props)) !== null && _a !== void 0 ? _a : ""));
-            });
-            node.nodeValue = updatedContent;
-        };
-        // Update the content now, and set up the listeners for future updates.
-        updateNode();
-        this.watch(keys.map(([, key]) => key), updateNode);
-        // Return all the proxies found in the content.
-        return keys.map(([, key]) => this.store.get(key));
-    }
-    resolveDataAttribute(node, params) {
+    fetchRemote(fpath, params) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (this.skipNodes.has(node))
-                return;
-            const elem = node;
-            const dataAttr = (_a = elem.getAttribute) === null || _a === void 0 ? void 0 : _a.call(elem, ":data");
-            if (dataAttr) {
-                this.log(params, ":data attribute found in:\n", node);
-                elem.removeAttribute(":data");
-                const result = yield this.eval(dataAttr, { $elem: node }, params);
-                this.log(params, ":data", dataAttr, "=>", result);
-                yield this.update(result);
-            }
+            return fetch(fpath, { cache: (_a = params === null || params === void 0 ? void 0 : params.cache) !== null && _a !== void 0 ? _a : "default" }).then((res) => res.text());
         });
     }
-    resolveWatchAttribute(node, params) {
+    fetchLocal(fpath, params) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (this.skipNodes.has(node))
-                return;
-            const elem = node;
-            const watchAttr = (_a = elem.getAttribute) === null || _a === void 0 ? void 0 : _a.call(elem, "@watch");
-            if (watchAttr) {
-                this.log(params, "@watch attribute found in:\n", node);
-                // Remove the attribute from the node.
-                elem.removeAttribute("@watch");
-                // Compute the function's result and trace dependencies.
-                const fn = () => this.eval(watchAttr, { $elem: node }, params);
-                const [result, dependencies] = yield this.trace(fn);
-                this.log(params, "@watch", watchAttr, "=>", result);
-                // Watch for updates, and re-execute function if needed.
-                this.watch(dependencies, fn);
-            }
-        });
-    }
-    resolvePropAttributes(node, params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.skipNodes.has(node))
-                return;
-            const elem = node;
-            for (const attr of Array.from(elem.attributes || [])) {
-                if (attr.name.startsWith("$") && !KW_ATTRIBUTES.has(attr.name)) {
-                    this.log(params, attr.name, "attribute found in:\n", node);
-                    // Remove the attribute from the node.
-                    elem.removeAttribute(attr.name);
-                    // Apply any shorthand conversions if necessary.
-                    const propName = (ATTR_SHORTHANDS[attr.name] || attr.name).slice(1);
-                    // Compute the function's result and trace dependencies.
-                    const fn = () => this.eval(attr.value, { $elem: node }, params);
-                    const [result, dependencies] = yield this.trace(fn);
-                    this.log(params, attr.name, attr.value, "=>", result, `[${dependencies}]`);
-                    // Set the requested property value on the original node, and watch for updates.
-                    const prop = (0, attributes_1.attributeNameToCamelCase)(propName);
-                    this.watch(dependencies, () => __awaiter(this, void 0, void 0, function* () { return (node[prop] = yield fn()); }));
-                    node[prop] = result;
-                }
-            }
+            return this.fetchRemote(fpath, params);
         });
     }
-    resolveAttrAttributes(node, params) {
+    preprocessString(content, params) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.skipNodes.has(node))
-                return;
-            const elem = node;
-            for (const attr of Array.from(elem.attributes || [])) {
-                if (attr.name.startsWith(":") && !KW_ATTRIBUTES.has(attr.name)) {
-                    this.log(params, attr.name, "attribute found in:\n", node);
-                    // Remove the processed attributes from node.
-                    elem.removeAttribute(attr.name);
-                    // Apply any shorthand conversions if necessary.
-                    const attrName = (ATTR_SHORTHANDS[attr.name] || attr.name).slice(1);
-                    // Compute the function's result and trace dependencies.
-                    const fn = () => this.eval(attr.value, { $elem: node }, params);
-                    const [result, dependencies] = yield this.trace(fn);
-                    this.log(params, attr.name, attr.value, "=>", result, `[${dependencies}]`);
-                    // Set the requested property value on the original node, and watch for updates.
-                    this.watch(dependencies, () => __awaiter(this, void 0, void 0, function* () { return elem.setAttribute(attrName, yield fn()); }));
-                    elem.setAttribute(attrName, result);
-                }
-            }
+            this.log(params, "Preprocessing string content with params:\n", params);
+            const fragment = this.parseHTML(content, params);
+            yield this.preprocessNode(fragment, params);
+            return fragment;
         });
     }
-    resolveEventAttributes(node, params) {
+    preprocessLocal(fpath, params) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (this.skipNodes.has(node))
-                return;
-            const elem = node;
-            for (const attr of Array.from(elem.attributes || [])) {
-                if (attr.name.startsWith("@") && !KW_ATTRIBUTES.has(attr.name)) {
-                    this.log(params, attr.name, "attribute found in:\n", node);
-                    // Remove the processed attributes from node.
-                    elem.removeAttribute(attr.name);
-                    (_a = node.addEventListener) === null || _a === void 0 ? void 0 : _a.call(node, attr.name.substring(1), (event) => this.eval(attr.value, { $elem: node, $event: event }, params));
-                }
-            }
+            const content = yield this.fetchLocal(fpath, params);
+            return this.preprocessString(content, Object.assign(Object.assign({}, params), { dirpath: dirname(fpath), root: (_a = params === null || params === void 0 ? void 0 : params.root) !== null && _a !== void 0 ? _a : !fpath.endsWith(".tpl.html") }));
         });
     }
-    resolveForAttribute(node, params) {
+    preprocessRemote(fpath, params) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            if (this.skipNodes.has(node))
-                return;
-            const elem = node;
-            const forAttr = (_a = elem.getAttribute) === null || _a === void 0 ? void 0 : _a.call(elem, ":for");
-            if (forAttr) {
-                this.log(params, ":for attribute found in:\n", node);
-                // Remove the processed attributes from node.
-                elem.removeAttribute(":for");
-                // Ensure the node and its children are not processed by subsequent steps.
-                for (const child of traverse(node, this.skipNodes)) {
-                    this.skipNodes.add(child);
-                }
-                // Place the template node into a template element.
-                const parent = node.parentNode;
-                const template = node.ownerDocument.createElement("template");
-                parent.insertBefore(template, node);
-                template.append(node);
-                this.log(params, ":for template:\n", template);
-                // Tokenize the input by splitting it based on the format "{key} in {expression}".
-                const tokens = forAttr.split(" in ", 2);
-                if (tokens.length !== 2) {
-                    throw new Error(`Invalid :for format: \`${forAttr}\`. Expected "{key} in {expression}".`);
-                }
-                // Compute the container expression and trace dependencies.
-                let items = [];
-                let deps = [];
-                const [loopKey, itemsExpr] = tokens;
-                try {
-                    [items, deps] = yield this.trace(() => this.eval(itemsExpr, { $elem: node }, params));
-                    this.log(params, itemsExpr, "=>", items, `[${deps}]`);
-                }
-                catch (exc) {
-                    console.error(exc);
-                    return;
-                }
-                // Keep track of all the child nodes added.
-                const children = [];
-                // Define the function that will update the DOM.
-                const fn = (items) => __awaiter(this, void 0, void 0, function* () {
-                    this.log(params, ":for list items:", items);
-                    // Validate that the expression returns a list of items.
-                    if (!Array.isArray(items)) {
-                        console.error(`Expression did not yield a list: \`${itemsExpr}\` => \`${items}\``);
-                        return;
-                    }
-                    // Acquire the lock atomically.
-                    this.lock = this.lock.then(() => new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
-                        // Remove all the previously added children, if any.
-                        children.splice(0, children.length).forEach((child) => {
-                            parent.removeChild(child);
-                            // this.skipNodes.delete(child);
-                        });
-                        // Loop through the container items in reverse, because we insert from back to front.
-                        for (const item of items.slice(0).reverse()) {
-                            // Create a subrenderer that will hold the loop item and all node descendants.
-                            const subrenderer = this.clone();
-                            yield subrenderer.set(loopKey, item);
-                            // Create a new HTML element for each item and add them to parent node.
-                            const copy = node.cloneNode(true);
-                            parent.insertBefore(copy, template.nextSibling);
-                            // Also add the new element to the store.
-                            children.push(copy);
-                            // Since the element will be handled by a subrenderer, skip it in the source.
-                            this.skipNodes.add(copy);
-                            // Render the element using the subrenderer.
-                            yield subrenderer.mount(copy, params);
-                            this.log(params, "Rendered list child:\n", copy);
-                        }
-                        // Release the lock.
-                        resolve();
-                    })));
-                    // Return the lock so the whole operation can be awaited.
-                    return this.lock;
-                });
-                // Apply changes, and watch for updates in the dependencies.
-                this.watch(deps, () => __awaiter(this, void 0, void 0, function* () { return fn(yield this.eval(itemsExpr, { $elem: node }, params)); }));
-                return fn(items);
-            }
+            const cache = (params === null || params === void 0 ? void 0 : params.cache) || "default";
+            const content = yield fetch(fpath, { cache }).then((res) => res.text());
+            return this.preprocessString(content, Object.assign(Object.assign({}, params), { dirpath: dirname(fpath), root: (_a = params === null || params === void 0 ? void 0 : params.root) !== null && _a !== void 0 ? _a : !fpath.endsWith(".tpl.html") }));
         });
     }
-    resolveBindAttribute(node, params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
-            if (this.skipNodes.has(node))
-                return;
-            const elem = node;
-            const bindKey = (_a = elem.getAttribute) === null || _a === void 0 ? void 0 : _a.call(elem, ":bind");
-            if (bindKey) {
-                this.log(params, ":bind attribute found in:\n", node);
-                // The change events we listen for can be overriden by user.
-                const defaultEvents = ["change", "input"];
-                const updateEvents = ((_c = (_b = elem.getAttribute) === null || _b === void 0 ? void 0 : _b.call(elem, ":bind-events")) === null || _c === void 0 ? void 0 : _c.split(",")) || defaultEvents;
-                // If the element is of type checkbox, we bind to the "checked" property.
-                const prop = elem.getAttribute("type") === "checkbox" ? "checked" : "value";
-                // If the key is not found in our store, create it and initialize it with the node's value.
-                if (!this.store.has(bindKey))
-                    yield this.set(bindKey, elem[prop]);
-                // Set the node's value to our current value.
-                elem[prop] = this.get(bindKey);
-                // Watch for updates in the node's value.
-                for (const event of updateEvents) {
-                    node.addEventListener(event, () => this.set(bindKey, elem[prop]));
-                }
-                // Watch for updates in the store.
-                this.watch([bindKey], () => (elem[prop] = this.get(bindKey)));
-                // Remove the processed attributes from node.
-                elem.removeAttribute(":bind");
-                elem.removeAttribute(":bind-events");
-            }
+    clone() {
+        return new this.constructor(Object.fromEntries(this.store.entries()));
+    }
+    log(params, ...args) {
+        if (params === null || params === void 0 ? void 0 : params.debug)
+            console.debug(...args);
+    }
+    eval(expr_1) {
+        return __awaiter(this, arguments, void 0, function* (expr, args = {}, params) {
+            const proxy = (0, reactive_1.proxify)(this);
+            const result = yield safeEval(expr, proxy, Object.assign({}, args));
+            this.log(params, `eval \`${expr}\` => `, result);
+            return result;
         });
     }
-    resolveShowAttribute(node, params) {
+    preprocessNode(root, params) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
-            if (this.skipNodes.has(node))
-                return;
-            const elem = node;
-            const showExpr = (_b = (_a = node).getAttribute) === null || _b === void 0 ? void 0 : _b.call(_a, ":show");
-            if (showExpr) {
-                // Compute the function's result and trace dependencies.
-                const fn = () => this.eval(showExpr, { $elem: node }, params);
-                const [result, dependencies] = yield this.trace(fn);
-                this.log(params, ":show", showExpr, "=>", result, `[${dependencies}]`);
-                // If the result is false, remove the element from the DOM.
-                const parent = node.parentNode;
-                if (!result)
-                    parent.removeChild(node);
-                // Watch the dependencies, and re-evaluate the expression.
-                this.watch(dependencies, () => __awaiter(this, void 0, void 0, function* () {
-                    if ((yield fn()) && node.parentNode !== parent)
-                        parent.append(node);
-                    else if (Array.from(parent.childNodes).includes(node))
-                        node.remove();
-                }));
-                // Remove the processed attributes from node.
-                elem.removeAttribute(":show");
-            }
+            params = Object.assign({ dirpath: this.dirpath, maxdepth: 10 }, params);
+            const promises = new iterator_1.Iterator(traverse(root, this.skipNodes)).map((node) => __awaiter(this, void 0, void 0, function* () {
+                this.log(params, "Preprocessing node:\n", node);
+                // Resolve all the includes in the node.
+                yield plugins_1.resolveIncludes.call(this, node, params);
+                // Resolve all the relative paths in the node.
+                yield plugins_1.rebaseRelativePaths.call(this, node, params);
+            }));
+            // Wait for all the rendering operations to complete.
+            yield Promise.all(promises.generator());
         });
     }
-    mount(root, params) {
+    renderNode(root, params) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Resolve all the includes recursively first.
-            yield this.resolveIncludes(root, params);
             // Iterate over all the nodes and apply appropriate handlers.
             // Do these steps one at a time to avoid any potential race conditions.
             for (const node of traverse(root, this.skipNodes)) {
-                this.log(params, "Processing node:\n", node);
-                // Resolve the :show attribute in the node.
-                yield this.resolveShowAttribute(node, params);
+                this.log(params, "Rendering node:\n", node);
                 // Resolve the :data attribute in the node.
-                yield this.resolveDataAttribute(node, params);
-                // Resolve the @watch attribute in the node.
-                yield this.resolveWatchAttribute(node, params);
+                yield plugins_1.resolveDataAttribute.call(this, node, params);
                 // Resolve the :for attribute in the node.
-                yield this.resolveForAttribute(node, params);
+                yield plugins_1.resolveForAttribute.call(this, node, params);
+                // Resolve the $html attribute in the node.
+                yield plugins_1.resolveHtmlAttribute.call(this, node, params);
+                // Resolve the :show attribute in the node.
+                yield plugins_1.resolveShowAttribute.call(this, node, params);
+                // Resolve the @watch attribute in the node.
+                yield plugins_1.resolveWatchAttribute.call(this, node, params);
                 // Resolve the :bind attribute in the node.
-                yield this.resolveBindAttribute(node, params);
+                yield plugins_1.resolveBindAttribute.call(this, node, params);
                 // Resolve all $attributes in the node.
-                yield this.resolvePropAttributes(node, params);
+                yield plugins_1.resolvePropAttributes.call(this, node, params);
                 // Resolve all :attributes in the node.
-                yield this.resolveAttrAttributes(node, params);
+                yield plugins_1.resolveAttrAttributes.call(this, node, params);
                 // Resolve all @attributes in the node.
-                yield this.resolveEventAttributes(node, params);
+                yield plugins_1.resolveEventAttributes.call(this, node, params);
                 // Replace all the {{ variables }} in the text.
-                this.resolveTextNode(node, params);
+                yield plugins_1.resolveTextNodeExpressions.call(this, node, params);
             }
-            return this;
         });
     }
-    renderString(content, params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const fragment = this.parseHTML(content, params);
-            yield this.mount(fragment, params);
-            return fragment;
-        });
-    }
-    renderRemotePath(fpath, params) {
+    mount(root, params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const cache = (params === null || params === void 0 ? void 0 : params.cache) || "default";
-            const content = yield fetch(fpath, { cache }).then((res) => res.text());
-            return this.renderString(content, Object.assign(Object.assign({}, params), { fsroot: folderPath(fpath), isRoot: (params === null || params === void 0 ? void 0 : params.isRoot) || !fpath.endsWith(".tpl.html") }));
+            // Preprocess all the elements recursively first.
+            yield this.preprocessNode(root, params);
+            // Now that the DOM is complete, render all the nodes.
+            yield this.renderNode(root, params);
         });
     }
 }

package/dist/gulp.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const path = require("path");
 const stream = require("stream");
@@ -15,13 +24,12 @@ const index_1 = require("./index");
  */
 function mancha(context = {}, wwwroot = process.cwd()) {
     const renderer = new index_1.RendererImpl(context);
-    // Mancha.update(context);
     return through.obj(function (file, encoding, callback) {
         const catcher = (err) => {
             console.log(err);
             callback(err, file);
         };
-        const fsroot = path.dirname(file.path);
+        const dirpath = path.dirname(file.path);
         if (file.isNull()) {
             callback(null, file);
         }
@@ -29,12 +37,13 @@ function mancha(context = {}, wwwroot = process.cwd()) {
             if (file.isBuffer()) {
                 const chunk = file.contents.toString(encoding);
                 renderer
-                    .renderString(chunk, { fsroot, isRoot: !file.path.endsWith(".tpl.html") })
-                    .then((fragment) => {
+                    .preprocessString(chunk, { dirpath, root: !file.path.endsWith(".tpl.html") })
+                    .then((fragment) => __awaiter(this, void 0, void 0, function* () {
+                    yield renderer.renderNode(fragment);
                     const content = renderer.serializeHTML(fragment);
                     file.contents = Buffer.from(content, encoding);
                     callback(null, file);
-                })
+                }))
                     .catch(catcher);
             }
             else if (file.isStream()) {
@@ -50,8 +59,9 @@ function mancha(context = {}, wwwroot = process.cwd()) {
                 })
                     .on("end", () => {
                     renderer
-                        .renderString(docstr, { fsroot, isRoot: !file.path.endsWith(".tpl.html") })
-                        .then((document) => {
+                        .preprocessString(docstr, { dirpath, root: !file.path.endsWith(".tpl.html") })
+                        .then((document) => __awaiter(this, void 0, void 0, function* () {
+                        yield renderer.renderNode(document);
                         const content = renderer.serializeHTML(document);
                         const readable = new stream.Readable();
                         readable._read = function () { };
@@ -59,7 +69,7 @@ function mancha(context = {}, wwwroot = process.cwd()) {
                         readable.push(null);
                         file.contents = readable;
                         callback(null, file);
-                    })
+                    }))
                         .catch(catcher);
                 });
             }

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-import { ParserParams, RendererParams } from "./core";
 import { RendererImpl as WorkerRendererImpl } from "./worker";
+import { ParserParams, RenderParams } from "./interfaces";
 /** The Node Mancha renderer is just like the worker renderer, but it also uses the filesystem. */
 export declare class RendererImpl extends WorkerRendererImpl {
-    renderLocalPath(fpath: string, params?: RendererParams & ParserParams): Promise<DocumentFragment>;
+    fetchLocal(fpath: string, params?: RenderParams & ParserParams): Promise<string>;
 }
-export { folderPath, resolvePath } from "./core";
 export declare const Mancha: RendererImpl;

package/dist/index.js

@@ -9,27 +9,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Mancha = exports.resolvePath = exports.folderPath = exports.RendererImpl = void 0;
+exports.Mancha = exports.RendererImpl = void 0;
 const fs = require("fs/promises");
-const core_1 = require("./core");
 const worker_1 = require("./worker");
 /** The Node Mancha renderer is just like the worker renderer, but it also uses the filesystem. */
 class RendererImpl extends worker_1.RendererImpl {
-    renderLocalPath(fpath_1) {
-        return __awaiter(this, arguments, void 0, function* (fpath, params = { encoding: "utf8" }) {
-            const content = yield fs.readFile(fpath, { encoding: params.encoding });
-            return this.renderString(content.toString(), {
-                fsroot: (0, core_1.folderPath)(fpath),
-                // Determine whether a root node is needed based on filename.
-                isRoot: params.isRoot || !fpath.endsWith(".tpl.html"),
-            });
+    fetchLocal(fpath, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return fs.readFile(fpath, { encoding: (params === null || params === void 0 ? void 0 : params.encoding) || "utf8" });
         });
     }
 }
 exports.RendererImpl = RendererImpl;
-// Re-exports from core.
-var core_2 = require("./core");
-Object.defineProperty(exports, "folderPath", { enumerable: true, get: function () { return core_2.folderPath; } });
-Object.defineProperty(exports, "resolvePath", { enumerable: true, get: function () { return core_2.resolvePath; } });
 // Export the renderer instance directly.
 exports.Mancha = new RendererImpl();