@bookshop/hugo-engine 3.5.0 → 3.5.1

package/.nyc_output/processinfo/{0abf820b-2028-4355-a51f-2ae7ceb14fc6.json → 0576b405-4d6f-416a-a012-1cd6714d2de3.json}

@@ -1 +1 @@
-{"parent":"5217b0dd-26fb-4b8d-af21-def9fd98ee74","pid":5428,"argv":["/opt/hostedtoolcache/node/16.20.0/x64/bin/node","/home/runner/work/bookshop/bookshop/javascript-modules/node_modules/ava/lib/worker/subprocess.js"],"execArgv":[],"cwd":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine","time":1683759482562,"ppid":5417,"coverageFilename":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine/.nyc_output/0abf820b-2028-4355-a51f-2ae7ceb14fc6.json","externalId":"","uuid":"0abf820b-2028-4355-a51f-2ae7ceb14fc6","files":[]}
+{"parent":"2fdbc94b-8ef1-4abe-8419-3b1f5ae13538","pid":5527,"argv":["/opt/hostedtoolcache/node/16.20.0/x64/bin/node","/home/runner/work/bookshop/bookshop/javascript-modules/node_modules/ava/lib/worker/subprocess.js"],"execArgv":[],"cwd":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine","time":1683882586943,"ppid":5494,"coverageFilename":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine/.nyc_output/0576b405-4d6f-416a-a012-1cd6714d2de3.json","externalId":"","uuid":"0576b405-4d6f-416a-a012-1cd6714d2de3","files":[]}

package/.nyc_output/processinfo/{0c4785c3-d657-4de0-97e2-a5c8bed13440.json → 1186c40f-ab1b-4fc3-8c8f-905478755bdd.json}

@@ -1 +1 @@
-{"parent":"5217b0dd-26fb-4b8d-af21-def9fd98ee74","pid":5434,"argv":["/opt/hostedtoolcache/node/16.20.0/x64/bin/node","/home/runner/work/bookshop/bookshop/javascript-modules/node_modules/ava/lib/worker/subprocess.js"],"execArgv":[],"cwd":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine","time":1683759482573,"ppid":5417,"coverageFilename":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine/.nyc_output/0c4785c3-d657-4de0-97e2-a5c8bed13440.json","externalId":"","uuid":"0c4785c3-d657-4de0-97e2-a5c8bed13440","files":[]}
+{"parent":"2fdbc94b-8ef1-4abe-8419-3b1f5ae13538","pid":5511,"argv":["/opt/hostedtoolcache/node/16.20.0/x64/bin/node","/home/runner/work/bookshop/bookshop/javascript-modules/node_modules/ava/lib/worker/subprocess.js"],"execArgv":[],"cwd":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine","time":1683882586504,"ppid":5494,"coverageFilename":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine/.nyc_output/1186c40f-ab1b-4fc3-8c8f-905478755bdd.json","externalId":"","uuid":"1186c40f-ab1b-4fc3-8c8f-905478755bdd","files":[]}

package/.nyc_output/processinfo/2fdbc94b-8ef1-4abe-8419-3b1f5ae13538.json

@@ -0,0 +1 @@
+{"parent":null,"pid":5494,"argv":["/opt/hostedtoolcache/node/16.20.0/x64/bin/node","/home/runner/work/bookshop/bookshop/javascript-modules/node_modules/ava/cli.js","-v"],"execArgv":[],"cwd":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine","time":1683882585987,"ppid":5483,"coverageFilename":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine/.nyc_output/2fdbc94b-8ef1-4abe-8419-3b1f5ae13538.json","externalId":"","uuid":"2fdbc94b-8ef1-4abe-8419-3b1f5ae13538","files":[]}

package/.nyc_output/processinfo/{5ab837f9-47fd-4613-be9e-8cad7f893cb6.json → 9afa86b4-7892-4e9a-b022-45b2ba35af2a.json}

@@ -1 +1 @@
-{"parent":"5217b0dd-26fb-4b8d-af21-def9fd98ee74","pid":5451,"argv":["/opt/hostedtoolcache/node/16.20.0/x64/bin/node","/home/runner/work/bookshop/bookshop/javascript-modules/node_modules/ava/lib/worker/subprocess.js"],"execArgv":[],"cwd":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine","time":1683759483129,"ppid":5417,"coverageFilename":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine/.nyc_output/5ab837f9-47fd-4613-be9e-8cad7f893cb6.json","externalId":"","uuid":"5ab837f9-47fd-4613-be9e-8cad7f893cb6","files":[]}
+{"parent":"2fdbc94b-8ef1-4abe-8419-3b1f5ae13538","pid":5505,"argv":["/opt/hostedtoolcache/node/16.20.0/x64/bin/node","/home/runner/work/bookshop/bookshop/javascript-modules/node_modules/ava/lib/worker/subprocess.js"],"execArgv":[],"cwd":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine","time":1683882586497,"ppid":5494,"coverageFilename":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine/.nyc_output/9afa86b4-7892-4e9a-b022-45b2ba35af2a.json","externalId":"","uuid":"9afa86b4-7892-4e9a-b022-45b2ba35af2a","files":[]}

package/.nyc_output/processinfo/{6671a456-fd5a-43f9-8289-01bfd323ba6a.json → e261f702-c88f-4b27-aebb-f0ddcd3d512e.json}

@@ -1 +1 @@
-{"parent":"5217b0dd-26fb-4b8d-af21-def9fd98ee74","pid":5450,"argv":["/opt/hostedtoolcache/node/16.20.0/x64/bin/node","/home/runner/work/bookshop/bookshop/javascript-modules/node_modules/ava/lib/worker/subprocess.js"],"execArgv":[],"cwd":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine","time":1683759483075,"ppid":5417,"coverageFilename":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine/.nyc_output/6671a456-fd5a-43f9-8289-01bfd323ba6a.json","externalId":"","uuid":"6671a456-fd5a-43f9-8289-01bfd323ba6a","files":[]}
+{"parent":"2fdbc94b-8ef1-4abe-8419-3b1f5ae13538","pid":5534,"argv":["/opt/hostedtoolcache/node/16.20.0/x64/bin/node","/home/runner/work/bookshop/bookshop/javascript-modules/node_modules/ava/lib/worker/subprocess.js"],"execArgv":[],"cwd":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine","time":1683882586987,"ppid":5494,"coverageFilename":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine/.nyc_output/e261f702-c88f-4b27-aebb-f0ddcd3d512e.json","externalId":"","uuid":"e261f702-c88f-4b27-aebb-f0ddcd3d512e","files":[]}

package/.nyc_output/processinfo/index.json

@@ -1 +1 @@
-{"processes":{"0abf820b-2028-4355-a51f-2ae7ceb14fc6":{"parent":"5217b0dd-26fb-4b8d-af21-def9fd98ee74","children":[]},"0c4785c3-d657-4de0-97e2-a5c8bed13440":{"parent":"5217b0dd-26fb-4b8d-af21-def9fd98ee74","children":[]},"5217b0dd-26fb-4b8d-af21-def9fd98ee74":{"parent":null,"children":["0abf820b-2028-4355-a51f-2ae7ceb14fc6","0c4785c3-d657-4de0-97e2-a5c8bed13440","5ab837f9-47fd-4613-be9e-8cad7f893cb6","6671a456-fd5a-43f9-8289-01bfd323ba6a"]},"5ab837f9-47fd-4613-be9e-8cad7f893cb6":{"parent":"5217b0dd-26fb-4b8d-af21-def9fd98ee74","children":[]},"6671a456-fd5a-43f9-8289-01bfd323ba6a":{"parent":"5217b0dd-26fb-4b8d-af21-def9fd98ee74","children":[]}},"files":{},"externalIds":{}}
+{"processes":{"0576b405-4d6f-416a-a012-1cd6714d2de3":{"parent":"2fdbc94b-8ef1-4abe-8419-3b1f5ae13538","children":[]},"1186c40f-ab1b-4fc3-8c8f-905478755bdd":{"parent":"2fdbc94b-8ef1-4abe-8419-3b1f5ae13538","children":[]},"2fdbc94b-8ef1-4abe-8419-3b1f5ae13538":{"parent":null,"children":["0576b405-4d6f-416a-a012-1cd6714d2de3","1186c40f-ab1b-4fc3-8c8f-905478755bdd","9afa86b4-7892-4e9a-b022-45b2ba35af2a","e261f702-c88f-4b27-aebb-f0ddcd3d512e"]},"9afa86b4-7892-4e9a-b022-45b2ba35af2a":{"parent":"2fdbc94b-8ef1-4abe-8419-3b1f5ae13538","children":[]},"e261f702-c88f-4b27-aebb-f0ddcd3d512e":{"parent":"2fdbc94b-8ef1-4abe-8419-3b1f5ae13538","children":[]}},"files":{},"externalIds":{}}

package/lib/engine.js

@@ -2,7 +2,6 @@ import compressedHugoWasm from "../full-hugo-renderer/hugo_renderer.wasm.gz";
 import { gunzipSync } from 'fflate';
 import translateTextTemplate from './translateTextTemplate.js';
 import { IdentifierParser } from './hugoIdentifierParser.js';
-import { version } from '../package.json';
 
 const sleep = (ms = 0) => {
     return new Promise(r => setTimeout(r, ms));
@@ -42,9 +41,12 @@ export class Engine {
         this.key = 'hugo';
         this.name = options.name;
         this.files = options.files;
-        this.origin = document.currentScript?.src || `/bookshop.js`;
+        this.origin = (typeof document === 'undefined' ? '' : document.currentScript?.src) || `/bookshop.js`;
+        this.synthetic = options.synthetic ?? false;
 
-        this.initializeHugo();
+        if (!this.synthetic) {
+            this.initializeHugo();
+        }
     }
 
     async initializeHugo() {
@@ -79,6 +81,20 @@ export class Engine {
 
         const componentSuccess = window["writeHugoFiles"](JSON.stringify(mappedFiles));
         const templateSuccess = window["writeHugoFiles"](JSON.stringify(templates));
+
+        // BIG OL' TODO: Writing these files ahead of render() seems to be load-bearing,
+        // which doesn't yet make sense to me.
+        // If these files are created for the first time in render(), the site doesn't
+        // appear to build (need to extract some logs from hugo to determine why).
+        // Perplexingly, writing then building in eval() appears to have been working
+        // fine in the same case.
+        // My suspicion would be something around our changeEvents() handling
+        // in the Hugo builder, but I don't know why that wouldn't affect eval()... 🤷‍♂️
+        // For now, the load-bearing stubs will live in this Hugo initialization.
+        window.writeHugoFiles(JSON.stringify({
+            "layouts/index.html": "Uninitialized Layout",
+            "content/_index.md": "{ \”initialized\": false }\n"
+        }));
     }
 
     async initializeLocalCompressedHugo() {
@@ -210,9 +226,9 @@ export class Engine {
             const component_regex = /execute of template failed: template: ([^:]+):\d/ig;
             let file_stack = [...error_string.matchAll(component_regex)].map(([, file]) => `layouts/${file}`);
             if (file_stack.length) {
-                const deepest_errored_component = file_stack[file_stack.length-1];
+                const deepest_errored_component = file_stack[file_stack.length - 1];
                 const error_chunks = error_string.split("execute of template failed:");
-                const error_msg = error_chunks[error_chunks.length-1] ?? "template error";
+                const error_msg = error_chunks[error_chunks.length - 1] ?? "template error";
                 window.writeHugoFiles(JSON.stringify({
                     [deepest_errored_component]: [
                         `<div style="padding: 10px; background-color: lightcoral; color: black; font-weight: bold;">`,
@@ -232,7 +248,7 @@ export class Engine {
                 return `layouts/partials/bookshop/components/${file}/${filename}.hugo.html`;
             });
             if (file_stack.length) {
-                const deepest_errored_component = file_stack[file_stack.length-1];
+                const deepest_errored_component = file_stack[file_stack.length - 1];
                 window.writeHugoFiles(JSON.stringify({
                     [deepest_errored_component]: [
                         `<div class="bookshop_error" style="padding: 10px; background-color: lightcoral; color: black; font-weight: bold;">`,
@@ -308,9 +324,25 @@ export class Engine {
     }
 
     async eval(str, props = [{}], logger) {
-        while (!window.buildHugo) await sleep(10);
+        if (!this.synthetic) {
+            while (!window.buildHugo) await sleep(10);
+        }
         let props_obj = props.reduce((a, b) => { return { ...a, ...b } });
         let full_props = props_obj;
+        str = str.trim();
+
+        // We can return early if we're evaluating a literal string or digit
+        if (/^".*"$|^`.*`$|^\d+(\.\d+)?$|^true$|^false$/.test(str)) {
+            logger?.log?.(`Unwrapping the string ${str}`);
+            try {
+                if (/^`.*`$/.test(str)) {
+                    return JSON.parse(str.replace(/^`|`$/g, '"'));
+                }
+                return JSON.parse(str);
+            } catch (e) {
+                logger?.log?.(`Was not valid JSON for some reason. Moving on...`);
+            }
+        }
 
         // We're capable of looking up a simple variable
         // (and it's hard to pass to wasm since we store variables on the context)
@@ -336,17 +368,11 @@ export class Engine {
             const process = async (obj) => {
                 for (const [k, v] of Object.entries(obj)) {
                     if (typeof v === "string") {
-                        if (/^".*"$/.test(v)) {
-                            // Normalized strings look like "\"string\""
-                            logger?.log?.(`Unwrapping the string ${k}: ${v}`);
-                            obj[k] = JSON.parse(v);
-                        } else {
-                            // No inner quotes means it needs to be evaled again
-                            logger?.log?.(`Evaluating the inner ${k}: ${v}`);
-                            obj[k] = await this.eval(v, [props_obj], logger.nested());
-                        }
+                        logger?.log?.(`Evaluating the inner ${k}: ${v}`);
+                        obj[k] = await this.eval(v, [props_obj], logger?.nested?.());
                     } else if (typeof v === "object") {
                         logger?.log?.(`Processing the inner object ${k}`);
+                        process(v);
                     }
                 }
             }
@@ -380,6 +406,11 @@ export class Engine {
             }
         }).join('');
         const eval_str = `${variable_decl}{{ with .Params.props }}${assignments}{{ jsonify (${str}) }}{{ end }}`;
+
+        if (this.synthetic) {
+            return null;
+        }
+
         window.writeHugoFiles(JSON.stringify({
             "layouts/index.html": eval_str,
             "content/_index.md": JSON.stringify({ props: props_obj, full_props: full_props }, null, 2)

package/lib/engine.test.js

@@ -1,5 +1,82 @@
 import test from 'ava';
+import { Engine } from './engine__test__.js';
 
-test("stub", async t => {
-    t.pass()
+let engine = null, logger = null;
+test.before(async t => {
+    engine = new Engine({ synthetic: true });
+    logger = {
+        log: (str) => console.log(str),
+        nested: () => logger,
+    }
+});
+
+test("eval value", async t => {
+    const val = await engine.eval(`.test`, [{ test: 'bookshop' }]);
+    t.is(val, 'bookshop');
+});
+
+test("eval variable", async t => {
+    const val = await engine.eval(`$var`, [{ "$var": 'string' }, { test: 'bookshop' }]);
+    t.is(val, 'string');
+});
+
+test("eval literals", async t => {
+    let val = await engine.eval(`"test"`, [{}]);
+    t.is(val, 'test');
+
+    val = await engine.eval("`test`", [{}]);
+    t.is(val, 'test');
+
+    val = await engine.eval("4", [{}]);
+    t.is(val, 4);
+
+    val = await engine.eval("99.9", [{}]);
+    t.is(val, 99.9);
+
+    val = await engine.eval("true", [{}]);
+    t.is(val, true);
+
+    val = await engine.eval("false", [{}]);
+    t.is(val, false);
+});
+
+test("eval through dot scope", async t => {
+    const val_later = await engine.eval(`.test`, [{ test: 'bookshop' }, { ".": { test: 'inner_bookshop' } }]);
+    t.is(val_later, 'inner_bookshop');
+
+    const val_earlier = await engine.eval(`.test`, [{ ".": { test: 'inner_bookshop' } }, { test: 'bookshop' }]);
+    t.is(val_earlier, 'inner_bookshop');
+});
+
+test("access dot scope", async t => {
+    const dot = await engine.eval(`.`, [{ test: 'bookshop' }]);
+    t.deepEqual(dot, { test: 'bookshop' });
+
+    const dot_dot = await engine.eval(`.`, [{ test: 'bookshop' }, { ".": { test: 'inner_bookshop' } }]);
+    t.deepEqual(dot_dot, { test: 'inner_bookshop' });
+});
+
+test("eval literal dict", async t => {
+    const dot = await engine.eval(`(dict "zanzibar" "gin")`, [{}]);
+    t.deepEqual(dot, { zanzibar: 'gin' });
+});
+
+test("eval dict with scope access", async t => {
+    const dot = await engine.eval(`(dict "zanzibar" .live)`, [{ live: "editing" }]);
+    t.deepEqual(dot, { zanzibar: 'editing' });
+});
+
+test("eval dict with variable access", async t => {
+    const dot = await engine.eval(`(dict "zanzibar" $live)`, [{ "$live": "editing" }]);
+    t.deepEqual(dot, { zanzibar: 'editing' });
+});
+
+test("eval complex dict", async t => {
+    const dot = await engine.eval(`(dict "zanzibar" (slice .edit .live) "and" "a_literal")`, [{ live: "editing" }, { edit: "live" }]);
+    t.deepEqual(dot, { zanzibar: ['live', 'editing'], and: 'a_literal' });
+});
+
+test("eval array index", async t => {
+    const dot = await engine.eval(`(index .live 1)`, [{ live: ["editing", "lively"] }]);
+    t.deepEqual(dot, "lively");
 });

package/lib/engine__test__.js

@@ -0,0 +1,445 @@
+// import compressedHugoWasm from "../full-hugo-renderer/hugo_renderer.wasm.gz";
+import { gunzipSync } from 'fflate';
+import translateTextTemplate from './translateTextTemplate.js';
+import { IdentifierParser } from './hugoIdentifierParser.js';
+
+const sleep = (ms = 0) => {
+    return new Promise(r => setTimeout(r, ms));
+}
+
+const dig = (obj, path) => {
+    if (typeof path === 'string') path = path.replace(/\[(\d+)]/g, '.$1').split('.');
+    obj = obj[path.shift()];
+    if (obj && path.length) return dig(obj, path);
+    return obj;
+}
+
+let mapHugoVariablesToParams = (obj, path) => {
+    let resolved = {};
+    for (let [k, v] of Object.entries(obj)) {
+        if (k.startsWith('$')) {
+            const remapped = `__bksh_${k.substring(1)}`;
+            obj[remapped] = v;
+            resolved[k] = `${path}.${remapped}`;
+        } else {
+            if (v && typeof v === 'object' && !Array.isArray(v)) {
+                resolved = { ...resolved, ...mapHugoVariablesToParams(v, `${path}.${k}`) }
+            }
+        }
+    }
+    return resolved
+}
+
+export class Engine {
+    constructor(options) {
+        options = {
+            name: "Hugo",
+            files: {},
+            ...options,
+        };
+
+        this.key = 'hugo';
+        this.name = options.name;
+        this.files = options.files;
+        this.origin = (typeof document === 'undefined' ? '' : document.currentScript?.src) || `/bookshop.js`;
+        this.synthetic = options.synthetic ?? false;
+
+        if (!this.synthetic) {
+            this.initializeHugo();
+        }
+    }
+
+    async initializeHugo() {
+        const templates = {
+            "layouts/partials/bookshop.html": (await import("../bookshop-hugo-templates/bookshop.html")).default,
+            "layouts/partials/bookshop_scss.html": (await import("../bookshop-hugo-templates/bookshop_scss.html")).default,
+            "layouts/partials/bookshop_partial.html": (await import("../bookshop-hugo-templates/bookshop_partial.html")).default,
+            "layouts/partials/bookshop_component_browser.html": (await import("../bookshop-hugo-templates/bookshop_component_browser.html")).default,
+            "layouts/partials/bookshop_bindings.html": (await import("../bookshop-hugo-templates/bookshop_bindings.html")).default,
+            "layouts/partials/_bookshop/helpers/component.html": (await import("../bookshop-hugo-templates/helpers/component.html")).default,
+            "layouts/partials/_bookshop/helpers/component_key.html": (await import("../bookshop-hugo-templates/helpers/component_key.html")).default,
+            "layouts/partials/_bookshop/helpers/partial.html": (await import("../bookshop-hugo-templates/helpers/partial.html")).default,
+            "layouts/partials/_bookshop/helpers/partial_key.html": (await import("../bookshop-hugo-templates/helpers/partial_key.html")).default,
+            "layouts/partials/_bookshop/errors/bad_bookshop_tag.html": (await import("../bookshop-hugo-templates/errors/bad_bookshop_tag.html")).default,
+            "layouts/partials/_bookshop/errors/err.html": (await import("../bookshop-hugo-templates/errors/err.html")).default,
+        };
+
+        templates["config.toml"] = "params.env_bookshop_live = true";
+
+        // When this script is run locally, the hugo wasm is loaded as binary rather than output as a file.
+        if (compressedHugoWasm?.constructor === Uint8Array) {
+            await this.initializeInlineHugo();
+        } else {
+            await this.initializeLocalCompressedHugo();
+        }
+
+        // TODO: Tidy
+        const mappedFiles = {};
+        for (const file of Object.entries(this.files)) {
+            mappedFiles[`layouts/partials/bookshop/${file[0]}`] = translateTextTemplate(file[1], {});
+        }
+
+        const componentSuccess = window["writeHugoFiles"](JSON.stringify(mappedFiles));
+        const templateSuccess = window["writeHugoFiles"](JSON.stringify(templates));
+
+        // BIG OL' TODO: Writing these files ahead of render() seems to be load-bearing,
+        // which doesn't yet make sense to me.
+        // If these files are created for the first time in render(), the site doesn't
+        // appear to build (need to extract some logs from hugo to determine why).
+        // Perplexingly, writing then building in eval() appears to have been working
+        // fine in the same case.
+        // My suspicion would be something around our changeEvents() handling
+        // in the Hugo builder, but I don't know why that wouldn't affect eval()... 🤷‍♂️
+        // For now, the load-bearing stubs will live in this Hugo initialization.
+        window.writeHugoFiles(JSON.stringify({
+            "layouts/index.html": "Uninitialized Layout",
+            "content/_index.md": "{ \”initialized\": false }\n"
+        }));
+    }
+
+    async initializeLocalCompressedHugo() {
+        try {
+
+            let prefetched = {};
+            if (typeof window !== "undefined" && window?.CloudCannon && window?.CloudCannon?.prefetchedFiles) {
+                prefetched = await window.CloudCannon.prefetchedFiles?.();
+                this.availablePrefetchKeys = Object.keys(prefetched);
+            }
+
+            const go = new Go();
+            const compressedWasmOrigin = this.origin.replace(/\/[^\.\/]+\.(min\.)?js/, compressedHugoWasm.replace(/^\./, ''));
+            const compressedWasmPath = (new URL(compressedWasmOrigin)).pathname;
+
+            let compressedBuffer;
+            if (prefetched[compressedWasmPath]) {
+                compressedBuffer = await prefetched[compressedWasmPath]?.arrayBuffer();
+                this.loadedFrom = "prefetch";
+            } else {
+                const compressedResponse = await fetch(compressedWasmOrigin);
+                compressedBuffer = await compressedResponse.arrayBuffer();
+                this.loadedFrom = "network";
+            }
+
+            const renderer = gunzipSync(new Uint8Array(compressedBuffer));
+
+            // Check the magic word at the start of the buffer as a way to verify the CDN download worked.
+            const isWasm = ([...renderer.slice(0, 4)]).map(g => g.toString(16).padStart(2, '0')).join('') === "0061736d";
+            if (!isWasm) throw "Not WASM";
+
+            const compressedResult = await WebAssembly.instantiate(renderer, go.importObject);
+            go.run(compressedResult.instance);
+        } catch (e) {
+            console.error("Couldn't load the local compressed Hugo WASM");
+            console.error(e);
+        }
+    }
+
+    async initializeInlineHugo() {
+        const go = new Go();
+        const buffer = compressedHugoWasm.buffer;
+        const renderer = gunzipSync(new Uint8Array(buffer));
+        const result = await WebAssembly.instantiate(renderer, go.importObject);
+        go.run(result.instance);
+    }
+
+    getSharedKey(name) {
+        return `shared/hugo/${name}.hugo.html`;
+    }
+
+    getShared(name) {
+        const key = this.getSharedKey(name);
+        return this.files?.[key];
+    }
+
+    getComponentKey(name) {
+        const base = name.split("/").reverse()[0];
+        return `components/${name}/${base}.hugo.html`;
+    }
+
+    getComponent(name) {
+        const key = this.getComponentKey(name);
+        return this.files?.[key];
+    }
+
+    hasComponent(name) {
+        const key = this.getComponentKey(name);
+        return !!this.files?.[key];
+    }
+
+    hasShared(name) {
+        const key = this.getSharedKey(name);
+        return !!this.files?.[key];
+    }
+
+    resolveComponentType(name) {
+        if (this.hasComponent(name)) return 'component';
+        if (this.hasShared(name)) return 'shared';
+        return false;
+    }
+
+    transformData(data) {
+        return {
+            Params: data
+        };
+    }
+
+    async storeMeta(meta = {}) {
+        while (!window.writeHugoFiles) {
+            await sleep(100);
+        };
+        window.writeHugoFiles(JSON.stringify({
+            "config.toml": [
+                meta.baseurl ? `baseURL = ${meta.baseurl}` : "",
+                meta.copyright ? `copyright = ${meta.copyright}` : "",
+                meta.title ? `title = ${meta.title}` : "",
+                "params.env_bookshop_live = true"
+            ].join('\n')
+        }));
+        const err = window.initHugoConfig();
+        if (err) {
+            console.error(err);
+        }
+
+        // window.loadHugoBookshopMeta(JSON.stringify(meta));
+    }
+
+    async storeInfo(info = {}) {
+        while (!window.writeHugoFiles) {
+            await sleep(100);
+        };
+
+        const data = info?.data;
+        if (!data || typeof data !== "object") return;
+        const files = {};
+        for (const [file, contents] of Object.entries(data)) {
+            files[`data/${file}.json`] = JSON.stringify(contents);
+        }
+        window.writeHugoFiles(JSON.stringify(files));
+    }
+
+    /**
+     * Tries to parse an error message and patch up the components
+     * in a rudimentary way before a rebuild.
+     */
+    async componentQuack(error_string = "", log_messages = []) {
+        try {
+            const component_regex = /execute of template failed: template: ([^:]+):\d/ig;
+            let file_stack = [...error_string.matchAll(component_regex)].map(([, file]) => `layouts/${file}`);
+            if (file_stack.length) {
+                const deepest_errored_component = file_stack[file_stack.length - 1];
+                const error_chunks = error_string.split("execute of template failed:");
+                const error_msg = error_chunks[error_chunks.length - 1] ?? "template error";
+                window.writeHugoFiles(JSON.stringify({
+                    [deepest_errored_component]: [
+                        `<div style="padding: 10px; background-color: lightcoral; color: black; font-weight: bold;">`,
+                        `Failed to render ${deepest_errored_component}. <br/>`,
+                        `<pre style="margin-top: 10px; background-color: lightcoral; border: solid 1px black; white-space: pre-line;">`,
+                        `<code style="font-family: monospace; color: black;">${error_msg.replace(/</, '&lt;')}</code></pre>`,
+                        `</div>`
+                    ].join('\n')
+                }));
+                return deepest_errored_component;
+            }
+
+            const error_logs = log_messages.filter(log => log.startsWith("ERROR")).join("\n");
+            const missing_regex = /Component "([^"]+)" does not exist/ig;
+            file_stack = [...error_logs.matchAll(missing_regex)].map(([, file]) => {
+                let filename = file.split('/').pop();
+                return `layouts/partials/bookshop/components/${file}/${filename}.hugo.html`;
+            });
+            if (file_stack.length) {
+                const deepest_errored_component = file_stack[file_stack.length - 1];
+                window.writeHugoFiles(JSON.stringify({
+                    [deepest_errored_component]: [
+                        `<div class="bookshop_error" style="padding: 10px; background-color: lightcoral; color: black; font-weight: bold;">`,
+                        `Failed to find component ${deepest_errored_component}`,
+                        `</div>`
+                    ].join('\n')
+                }));
+                return deepest_errored_component;
+            }
+        } catch (e) {
+            console.error(`ComponentQuack failed to patch things up: ${e}`);
+            return null;
+        }
+    }
+
+    async render(target, name, props, globals, logger) {
+        while (!window.buildHugo) {
+            logger?.log?.(`Waiting for the Hugo WASM to be available...`);
+            await sleep(100);
+        };
+
+        let writeFiles = {};
+
+        if (this.hasComponent(name)) {
+            writeFiles["layouts/index.html"] = `{{ partial "bookshop" (slice "${name}" .Params.component) }}`
+        } else if (this.hasShared(name)) {
+            writeFiles["layouts/index.html"] = `{{ partial "bookshop_partial" (slice "${name}" .Params.component) }}`
+        } else {
+            console.warn(`[hugo-engine] No component found for ${name}`);
+            return "";
+        }
+        logger?.log?.(`Going to render ${name}, with layout:`);
+        logger?.log?.(writeFiles["layouts/index.html"]);
+
+        if (!globals || typeof globals !== "object") globals = {};
+        props = {
+            ...globals, ...props,
+            env_bookshop_live: true
+        };
+
+        // If we have assigned a root scope we need to pass that in as the context
+        if (props["."]) props = props["."];
+        writeFiles["content/_index.md"] = JSON.stringify({
+            component: props
+        }, null, 2) + "\n";
+        window.writeHugoFiles(JSON.stringify(writeFiles));
+
+        window.hugo_wasm_logging = [];
+        let render_attempts = 1;
+        let buildError = window.buildHugo();
+        while (buildError && render_attempts < 5) {
+            if (this.componentQuack(buildError, window.hugo_wasm_logging) === null) {
+                // Can't find a template to overwrite and re-render
+                break;
+            }
+            // Try render again with the problem template stubbed out
+            window.hugo_wasm_logging = [];
+            buildError = window.buildHugo();
+            render_attempts += 1;
+        }
+
+        if (buildError) {
+            console.error(buildError);
+            return;
+        }
+
+        const output = window.readHugoFiles(JSON.stringify([
+            "public/index.html"
+        ]));
+
+        target.innerHTML = output["public/index.html"];
+        return;
+    }
+
+    async eval(str, props = [{}], logger) {
+        if (!this.synthetic) {
+            while (!window.buildHugo) await sleep(10);
+        }
+        let props_obj = props.reduce((a, b) => { return { ...a, ...b } });
+        let full_props = props_obj;
+        str = str.trim();
+
+        // We can return early if we're evaluating a literal string or digit
+        if (/^".*"$|^`.*`$|^\d+(\.\d+)?$|^true$|^false$/.test(str)) {
+            logger?.log?.(`Unwrapping the string ${str}`);
+            try {
+                if (/^`.*`$/.test(str)) {
+                    return JSON.parse(str.replace(/^`|`$/g, '"'));
+                }
+                return JSON.parse(str);
+            } catch (e) {
+                logger?.log?.(`Was not valid JSON for some reason. Moving on...`);
+            }
+        }
+
+        // We're capable of looking up a simple variable
+        // (and it's hard to pass to wasm since we store variables on the context)
+        if (/^\$/.test(str)) {
+            logger?.log?.(`Trying to short circuit to return a variable`);
+            if (props_obj[str]) return props_obj[str];
+        }
+
+        // If we have assigned a root scope we need to pass that in as the context
+        if (props_obj["."]) {
+            logger?.log?.(`Nesting the props object into its dot scope`);
+            props_obj = props_obj["."];
+        }
+
+        if (str === ".") {
+            logger?.log?.(`Short circuiting dot notation to return the scope`);
+            return props_obj;
+        }
+
+        let normalized = this.normalize(str);
+        if (typeof normalized === 'object') {
+            logger?.log?.(`Digging into the object ${JSON.stringify(normalized)}`);
+            const process = async (obj) => {
+                for (const [k, v] of Object.entries(obj)) {
+                    if (typeof v === "string") {
+                        logger?.log?.(`Evaluating the inner ${k}: ${v}`);
+                        obj[k] = await this.eval(v, [props_obj], logger?.nested?.());
+                    } else if (typeof v === "object") {
+                        logger?.log?.(`Processing the inner object ${k}`);
+                        process(v);
+                    }
+                }
+            }
+            await process(normalized);
+            return normalized;
+        }
+        if (/^\w+(\.\w+)*$/.test(normalized)) {
+            logger?.log?.(`Trying to short circuit to return the dot notation ${normalized}`);
+            // We're capable of looking up a simple dot notation access
+            const result = dig(props_obj, normalized);
+            if (result !== undefined) return result
+        }
+
+        // Rewrite array.0 into index array 0
+        str = str.replace(/(.*)\.(\d+)$/, (_, obj, index) => {
+            return `index (${obj}) ${index}`;
+        })
+
+        const variable_pairs = mapHugoVariablesToParams(full_props, ".Params.full_props");
+        const variable_decl = Object.entries(variable_pairs).map(([k, v]) => {
+            return `{{ ${k} := ${v} }}`
+        }).join('');
+
+        const assignments = Object.entries(props_obj).filter(([key]) => key.startsWith('$')).map(([key, value]) => {
+            if (Array.isArray(value)) {
+                return `{{ ${key} := index ( \`{"a": ${JSON.stringify(value)}}\` | transform.Unmarshal ) "a" }}`
+            } else if (typeof value === 'object') {
+                return `{{ ${key} := \`${JSON.stringify(value)}\` | transform.Unmarshal }}`
+            } else {
+                return `{{ ${key} := ${JSON.stringify(value)} }}`
+            }
+        }).join('');
+        const eval_str = `${variable_decl}{{ with .Params.props }}${assignments}{{ jsonify (${str}) }}{{ end }}`;
+
+        if (this.synthetic) {
+            return null;
+        }
+
+        window.writeHugoFiles(JSON.stringify({
+            "layouts/index.html": eval_str,
+            "content/_index.md": JSON.stringify({ props: props_obj, full_props: full_props }, null, 2)
+        }));
+
+        const buildError = window.buildHugo();
+        if (buildError) {
+            console.warn(buildError);
+            return;
+        }
+
+        const output = window.readHugoFiles(JSON.stringify([
+            "public/index.html"
+        ]))["public/index.html"];
+
+        try {
+            return JSON.parse(output);
+        } catch (e) {
+            logger?.log?.(`Error evaluating \`${str}\` in the Hugo engine`);
+            logger?.log?.(output);
+            return null;
+        }
+    }
+
+    normalize(str) {
+        return (new IdentifierParser(str)).build();
+    }
+
+    loader() {
+        // esbuild loader if required
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bookshop/hugo-engine",
   "packageManager": "yarn@3.0.0",
-  "version": "3.5.0",
+  "version": "3.5.1",
   "description": "Bookshop frontend Hugo renderer",
   "type": "module",
   "sideEffects": false,
@@ -14,11 +14,12 @@
     "*.js",
     "lib/*.js",
     "!**/*.test.js",
+    "!**/*__test__.js",
     "full-hugo-renderer/hugo_renderer.wasm.gz",
     "bookshop-hugo-templates/**/*"
   ],
   "scripts": {
-    "test": "nyc ava -v"
+    "test": "node prep__test__.js && nyc ava -v"
   },
   "author": "@bglw",
   "license": "MIT",
@@ -30,7 +31,7 @@
     "nyc": "^15.1.0"
   },
   "dependencies": {
-    "@bookshop/helpers": "3.5.0",
+    "@bookshop/helpers": "3.5.1",
     "esbuild": "^0.13.10",
     "fflate": "^0.7.3",
     "liquidjs": "9.28.0"

package/prep__test__.js

@@ -0,0 +1,5 @@
+import fs from "fs";
+
+let contents = fs.readFileSync("lib/engine.js", { encoding: "utf-8" });
+contents = contents.replace("import compressedHugoWasm", "// import compressedHugoWasm");
+fs.writeFileSync("lib/engine__test__.js", contents);

package/.nyc_output/processinfo/5217b0dd-26fb-4b8d-af21-def9fd98ee74.json

@@ -1 +0,0 @@
-{"parent":null,"pid":5417,"argv":["/opt/hostedtoolcache/node/16.20.0/x64/bin/node","/home/runner/work/bookshop/bookshop/javascript-modules/node_modules/ava/cli.js","-v"],"execArgv":[],"cwd":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine","time":1683759481967,"ppid":5406,"coverageFilename":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine/.nyc_output/5217b0dd-26fb-4b8d-af21-def9fd98ee74.json","externalId":"","uuid":"5217b0dd-26fb-4b8d-af21-def9fd98ee74","files":[]}