@bookshop/hugo-engine 3.3.2 → 3.4.0-alpha.2

package/full-hugo-renderer/main.go

@@ -0,0 +1,215 @@
+// Copyright 2015 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"path/filepath"
+	"syscall/js"
+
+	"github.com/fsnotify/fsnotify"
+	"github.com/gohugoio/hugo/config"
+	"github.com/gohugoio/hugo/deps"
+	"github.com/gohugoio/hugo/hugofs"
+	"github.com/gohugoio/hugo/hugolib"
+	"github.com/spf13/afero"
+)
+
+type bookshopSiteBuilder struct {
+	Cfg          config.Provider
+	Fs           *hugofs.Fs
+	Sites        *hugolib.HugoSites
+	changedFiles []string
+}
+
+// Load whatever source config file we have previously written to disk
+func (builder *bookshopSiteBuilder) LoadConfig() error {
+	cfg, _, err := hugolib.LoadConfig(hugolib.ConfigSourceDescriptor{
+		WorkingDir: "",
+		Fs:         builder.Fs.Source,
+		Filename:   "config.toml",
+	}, func(cfg config.Provider) error {
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	builder.Cfg = cfg
+
+	return nil
+}
+
+// Create our Hugo sites
+// TODO: I don't know how the lang aspects of Hugo
+// will interact with Hugo.
+func (builder *bookshopSiteBuilder) CreateSites() error {
+	if err := builder.LoadConfig(); err != nil {
+		fmt.Println(fmt.Sprintf("failed to load config: %s", err))
+		return fmt.Errorf("failed to load config: %w", err)
+	}
+
+	builder.Fs.PublishDir = hugofs.NewCreateCountingFs(builder.Fs.PublishDir)
+
+	sites, err := hugolib.NewHugoSites(deps.DepsCfg{
+		Fs:      builder.Fs,
+		Cfg:     builder.Cfg,
+		Running: true,
+	})
+	if err != nil {
+		fmt.Println(fmt.Sprintf("failed to create sites: %s", err))
+		return fmt.Errorf("failed to create sites: %w", err)
+	}
+	builder.Sites = sites
+
+	return nil
+}
+
+// Runs a standard Hugo build into our in-memory "public" directory
+func (builder *bookshopSiteBuilder) build(cfg hugolib.BuildCfg) error {
+	if builder.Sites == nil {
+		builder.CreateSites()
+	}
+
+	err := builder.Sites.Build(cfg, builder.changeEvents()...)
+
+	if err == nil {
+		logErrorCount := builder.Sites.NumLogErrors()
+		if logErrorCount > 0 {
+			err = fmt.Errorf("logged %d errors", logErrorCount)
+		}
+	}
+	if err != nil {
+		fmt.Errorf("Build failed: %s", err)
+		fmt.Println(fmt.Sprintf("Build failed: %s", err))
+		return err
+	}
+	return nil
+}
+
+// Writes content to the given file path in the in-memory filesystem
+func (builder *bookshopSiteBuilder) writeFile(filename, content string) {
+	if err := afero.WriteFile(builder.Fs.Source, filepath.FromSlash(filename), []byte(content), 0755); err != nil {
+		fmt.Println(fmt.Sprintf("Failed to write file: %s", err))
+	}
+
+	builder.changedFiles = append(builder.changedFiles, filename)
+}
+
+// Reads content from the given file path in the in-memory filesystem
+func (builder *bookshopSiteBuilder) readFile(filename string) string {
+	b, err := afero.ReadFile(builder.Fs.Source, filepath.Clean(filename))
+	if err != nil {
+		fmt.Println(fmt.Sprintf("Failed to read file: %s", err))
+	}
+	return string(b)
+}
+
+// Helper method to list out any files in our virtual fs
+func (builder *bookshopSiteBuilder) debugDir(dir string) {
+	files, err := afero.ReadDir(builder.Fs.Source, dir)
+	if err == nil {
+		for _, file := range files {
+			fmt.Println(fmt.Sprintf("%s > %+v", dir, file.Name()))
+		}
+	} else {
+		fmt.Println(fmt.Sprintf("Error debugging directory: %+v", err))
+	}
+}
+
+func (builder *bookshopSiteBuilder) changeEvents() []fsnotify.Event {
+	var events []fsnotify.Event
+
+	for _, v := range builder.changedFiles {
+		events = append(events, fsnotify.Event{
+			Name: v,
+			Op:   fsnotify.Write,
+		})
+	}
+
+	return events
+}
+
+var builder bookshopSiteBuilder
+var build_config hugolib.BuildCfg
+
+func main() {
+	fs_config := config.NewWithTestDefaults()
+	fs := hugofs.NewMem(fs_config)
+	builder = bookshopSiteBuilder{Fs: fs}
+	build_config = hugolib.BuildCfg{
+		NoBuildLock: true,
+	}
+
+	log.SetOutput(ioutil.Discard)
+
+	c := make(chan struct{}, 0)
+	js.Global().Set("initHugoConfig", js.FuncOf(initHugoConfig))
+	js.Global().Set("writeHugoFiles", js.FuncOf(writeHugoFiles))
+	js.Global().Set("readHugoFiles", js.FuncOf(readHugoFiles))
+	js.Global().Set("buildHugo", js.FuncOf(buildHugo))
+	<-c
+}
+
+func initHugoConfig(this js.Value, args []js.Value) interface{} {
+	if err := builder.LoadConfig(); err != nil {
+		fmt.Println(fmt.Sprintf("failed to load config: %s", err))
+		return fmt.Errorf("failed to load config: %w", err)
+	}
+	if err := builder.CreateSites(); err != nil {
+		fmt.Println(fmt.Sprintf("failed to create sites: %s", err))
+		return fmt.Errorf("failed to create sites: %w", err)
+	}
+	return nil
+}
+
+func writeHugoFiles(this js.Value, args []js.Value) interface{} {
+	var writeFiles map[string]string
+	err := json.Unmarshal([]byte(args[0].String()), &writeFiles)
+	if err != nil {
+		fmt.Println(fmt.Sprintf("Bad json: %+v", err))
+		return nil
+	}
+
+	for file_name, file_contents := range writeFiles {
+		builder.writeFile(file_name, file_contents)
+	}
+	return nil
+}
+
+func readHugoFiles(this js.Value, args []js.Value) interface{} {
+	var readFiles []string
+	err := json.Unmarshal([]byte(args[0].String()), &readFiles)
+	if err != nil {
+		fmt.Println(fmt.Sprintf("Bad json: %+v", err))
+		return nil
+	}
+
+	fileContents := make(map[string]interface{})
+	for _, file_name := range readFiles {
+		fileContents[file_name] = builder.readFile(file_name)
+	}
+
+	return js.ValueOf(fileContents)
+}
+
+func buildHugo(this js.Value, args []js.Value) interface{} {
+	if err := builder.build(build_config); err != nil {
+		return fmt.Sprintf("Build error: %+v", err)
+	}
+	return nil
+}

package/{hugo-renderer → full-hugo-renderer}/wasm_exec.js

@@ -48,7 +48,10 @@
 				outputBuf += decoder.decode(buf);
 				const nl = outputBuf.lastIndexOf("\n");
 				if (nl != -1) {
-					console.log(outputBuf.substr(0, nl));
+					// Disable all logs from the WASM side
+					if (window.log_hugo_wasm) {
+						console.log(outputBuf.substr(0, nl));
+					}
 					outputBuf = outputBuf.substr(nl + 1);
 				}
 				return buf.length;
@@ -499,7 +502,8 @@
 					},
 
 					"debug": (value) => {
-						console.log(value);
+						// Disable all logs from the WASM side
+						// console.log(value);	
 					},
 				}
 			};

package/lib/builder.js

@@ -9,12 +9,12 @@ export const extensions = [".hugo.html"];
 export const esbuildConfigFn = (esbuildConfig, options) => {
     esbuildConfig.loader = {
         ...esbuildConfig.loader,
+        ".html": "text",
         ".hugo.html": "text",
-        ".wasm": options?.hosted ? "file" : "binary",
         ".wasm.gz": options?.hosted ? "file" : "binary",
     };
 
-    const wasm_exec_banner = fs.readFileSync(path.join(__dirname, "../hugo-renderer/wasm_exec.js"));
+    const wasm_exec_banner = fs.readFileSync(path.join(__dirname, "../full-hugo-renderer/wasm_exec.js"));
     esbuildConfig.banner = {
         ...esbuildConfig.banner,
         js: (esbuildConfig.js ?? "") + wasm_exec_banner

package/lib/engine.js

@@ -1,5 +1,4 @@
-import hugoWasm from "../hugo-renderer/hugo_renderer.wasm";
-import compressedHugoWasm from "../hugo-renderer/hugo_renderer.wasm.gz";
+import compressedHugoWasm from "../full-hugo-renderer/hugo_renderer.wasm.gz";
 import { gunzipSync } from 'fflate';
 import translateTextTemplate from './translateTextTemplate.js';
 import { IdentifierParser } from './hugoIdentifierParser.js';
@@ -33,8 +32,24 @@ export class Engine {
     }
 
     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 (hugoWasm?.constructor === Uint8Array) {
+        if (compressedHugoWasm?.constructor === Uint8Array) {
             await this.initializeInlineHugo();
         } else {
             await this.initializeLocalCompressedHugo();
@@ -43,12 +58,11 @@ export class Engine {
         // TODO: Tidy
         const mappedFiles = {};
         for (const file of Object.entries(this.files)) {
-            mappedFiles[file[0]] = {
-                contents: translateTextTemplate(file[1], {})
-            }
+            mappedFiles[`layouts/partials/bookshop/${file[0]}`] = translateTextTemplate(file[1], {});
         }
 
-        const success = window.loadHugoBookshopPartials(JSON.stringify(mappedFiles));
+        const componentSuccess = window["writeHugoFiles"](JSON.stringify(mappedFiles));
+        const templateSuccess = window["writeHugoFiles"](JSON.stringify(templates));
     }
 
     async initializeLocalCompressedHugo() {
@@ -66,28 +80,25 @@ export class Engine {
             const compressedResult = await WebAssembly.instantiate(renderer, go.importObject);
             go.run(compressedResult.instance);
         } catch (e) {
-            await this.initializeLocalHugo();
+            console.error("Couldn't load the local compressed Hugo WASM");
+            console.error(e);
         }
     }
 
-    async initializeLocalHugo() {
+    async initializeInlineHugo() {
         const go = new Go();
-        const wasmOrigin = this.origin.replace(/\/[^\.\/]+\.(min\.)?js/, hugoWasm.replace(/^\./, ''));
-        const response = await fetch(wasmOrigin);
-        const buffer = await response.arrayBuffer();
-        const result = await WebAssembly.instantiate(buffer, go.importObject);
+        const buffer = compressedHugoWasm.buffer;
+        const renderer = gunzipSync(new Uint8Array(buffer));
+        const result = await WebAssembly.instantiate(renderer, go.importObject);
         go.run(result.instance);
     }
 
-    async initializeInlineHugo() {
-        const go = new Go();
-        const buffer = hugoWasm.buffer;
-        const result = await WebAssembly.instantiate(buffer, go.importObject);
-        go.run(result.instance);
+    getSharedKey(name) {
+        return `shared/hugo/${name}.hugo.html`;
     }
 
     getShared(name) {
-        const key = `shared/hugo/${name}.hugo.html`
+        const key = this.getSharedKey(name);
         return this.files?.[key];
     }
 
@@ -106,9 +117,14 @@ export class Engine {
         return !!this.files?.[key];
     }
 
+    hasShared(name) {
+        const key = this.getSharedKey(name);
+        return !!this.files?.[key];
+    }
+
     resolveComponentType(name) {
-        if (this.getComponent(name)) return 'component';
-        if (this.getShared(name)) return 'shared';
+        if (this.hasComponent(name)) return 'component';
+        if (this.hasShared(name)) return 'shared';
         return false;
     }
 
@@ -119,38 +135,58 @@ export class Engine {
     }
 
     async storeMeta(meta = {}) {
-        while (!window.loadHugoBookshopMeta) {
+        while (!window.writeHugoFiles) {
             await sleep(100);
         };
-        window.loadHugoBookshopMeta(JSON.stringify(meta));
+        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.loadHugoBookshopData) {
+        while (!window.writeHugoFiles) {
             await sleep(100);
         };
-        window.loadHugoBookshopData(JSON.stringify(info));
+
+        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));
     }
 
     async render(target, name, props, globals, logger) {
-        while (!window.renderHugo) {
+        while (!window.buildHugo) {
             logger?.log?.(`Waiting for the Hugo WASM to be available...`);
             await sleep(100);
         };
 
-        let source = this.getComponent(name);
-        // TODO: Remove the below check and update the live comments to denote shared
-        if (!source) source = this.getShared(name);
-        if (!source) {
+        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 source:`);
-        logger?.log?.(source);
-        // TODO: this template already exists on the other side of the wasm bounary
-        source = translateTextTemplate(source, {});
-        logger?.log?.(`Rewritten the template for ${name} to:`);
-        logger?.log?.(source);
+        logger?.log?.(`Going to render ${name}, with layout:`);
+        logger?.log?.(writeFiles["layouts/index.html"]);
+
         if (!globals || typeof globals !== "object") globals = {};
         props = {
             ...globals, ...props,
@@ -159,7 +195,25 @@ export class Engine {
 
         // If we have assigned a root scope we need to pass that in as the context
         if (props["."]) props = props["."];
-        const output = window.renderHugo(source, JSON.stringify(props));
+        writeFiles["content/_index.md"] = JSON.stringify({
+            component: props
+        }, null, 2) + "\n";
+        window.writeHugoFiles(JSON.stringify(writeFiles));
+
+        const buildResult = window.buildHugo();
+        if (buildResult) {
+            console.error(buildResult);
+            return;
+        }
+
+        const output = window.readHugoFiles(JSON.stringify([
+            "public/index.html"
+        ]));
+
+        target.innerHTML = output["public/index.html"];
+        return;
+
+        const outputs = window.renderHugo(source, JSON.stringify(props));
         if (/BKSHERR/.test(output)) {
             logger?.log?.(`Failed to render ${output}`);
             console.error(output);
@@ -171,7 +225,7 @@ export class Engine {
     }
 
     async eval(str, props = [{}]) {
-        while (!window.renderHugo) await sleep(10);
+        while (!window.buildHugo) await sleep(10);
         let props_obj = props.reduce((a, b) => { return { ...a, ...b } });
 
         // We're capable of looking up a simple variable
@@ -190,15 +244,28 @@ export class Engine {
 
         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.BookshopUnmarshal ) "a" }}`
+                return `{{ ${key} := index ( \`{"a": ${JSON.stringify(value)}}\` | transform.Unmarshal ) "a" }}`
             } else if (typeof value === 'object') {
-                return `{{ ${key} := \`${JSON.stringify(value)}\` | transform.BookshopUnmarshal }}`
+                return `{{ ${key} := \`${JSON.stringify(value)}\` | transform.Unmarshal }}`
             } else {
                 return `{{ ${key} := ${JSON.stringify(value)} }}`
             }
         }).join('');
-        const eval_str = `${assignments}{{ jsonify (${str}) }}`;
-        const output = window.renderHugo(eval_str, JSON.stringify(props_obj));
+        const eval_str = `{{ with .Params.props }}${assignments}{{ jsonify (${str}) }}{{ end }}`;
+        window.writeHugoFiles(JSON.stringify({
+            "layouts/index.html": eval_str,
+            "content/_index.md": JSON.stringify({ props: props_obj }, 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);

package/lib/hugoIdentifierParser.js

@@ -36,6 +36,11 @@ export class IdentifierParser {
       return `${variable}.${index}`;
     }
 
+    // strip the leading .Params. from basic variable references
+    // if (/^\s*\./.test(this.input)) {
+    //   return this.input.replace(/^\s*\.Params\.([^\.\s])/, '$1');
+    // }
+
     // strip the leading . from basic variable references
     if (/^\s*\./.test(this.input)) {
       return this.input.replace(/^\s*\.([^\.\s])/, '$1');

package/lib/translateTextTemplate.js

@@ -105,6 +105,9 @@ export default function (text, opts) {
         liveMarkup: true,
         ...opts
     }
+    if (!/bookshop/.test(text)) {
+        return text;
+    }
     const tokenizer = new Tokenizer(text.toString());
     const tokens = tokenizer.readTopLevelTokens();
     const output = [];

package/lib/translateTextTemplate.test.js

@@ -28,34 +28,40 @@ test("don't add live markup to bookshop_partial tags", t => {
     t.is(translateTextTemplate(input, {}), expected);
 });
 
-test("add live markup to assigns", t => {
+test("don't add live markup if no bookshop found", t => {
     let input = `{{ $a := .b }}`;
-    let expected = `{{ $a := .b }}{{ \`<!--bookshop-live context($a: (.b))-->\` | safeHTML }}`;
+    let expected = `{{ $a := .b }}`;
     t.is(translateTextTemplate(input, {}), expected);
+});
 
-    input = `{{ $a := .b | chomp }}`;
-    expected = `{{ $a := .b | chomp }}{{ \`<!--bookshop-live context($a: (.b | chomp))-->\` | safeHTML }}`;
+test("add live markup to assigns", t => {
+    let input = `{{ $a := .b }}bookshop`;
+    let expected = `{{ $a := .b }}{{ \`<!--bookshop-live context($a: (.b))-->\` | safeHTML }}bookshop`;
     t.is(translateTextTemplate(input, {}), expected);
 
-    input = `{{ $a = .b }}`;
-    expected = `{{ $a = .b }}{{ \`<!--bookshop-live reassign($a: (.b))-->\` | safeHTML }}`;
+    input = `{{ $a := .b | chomp }}bookshop`;
+    expected = `{{ $a := .b | chomp }}{{ \`<!--bookshop-live context($a: (.b | chomp))-->\` | safeHTML }}bookshop`;
+    t.is(translateTextTemplate(input, {}), expected);
+
+    input = `{{ $a = .b }}bookshop`;
+    expected = `{{ $a = .b }}{{ \`<!--bookshop-live reassign($a: (.b))-->\` | safeHTML }}bookshop`;
     t.is(translateTextTemplate(input, {}), expected);
 });
 
 test("add live markup to withs", t => {
-    const input = `{{ with .b }}<p>{{.}}</p>{{ end }}`;
+    const input = `{{ with .b }}<p>{{.}}</p>{{ end }}bookshop`;
     const expected = [`{{ with .b }}`,
         `{{ \`<!--bookshop-live stack-->\` | safeHTML }}`,
         `{{ \`<!--bookshop-live context(.: (.b))-->\` | safeHTML }}`,
         `<p>{{.}}</p>`,
         `{{ \`<!--bookshop-live unstack-->\` | safeHTML }}`,
-        `{{ end }}`
+        `{{ end }}bookshop`
     ].join('');
     t.is(translateTextTemplate(input, {}), expected);
 });
 
 test("add live markup to loops", t => {
-    const input = `{{ range .items }}<p>{{ . }}</p>{{ end }}`;
+    const input = `{{ range .items }}<p>{{ . }}</p>{{ end }}bookshop`;
     const expected = [`{{ $bookshop__live__iterator__keys := (slice) }}`,
         `{{ range $i, $e := (.items) }}{{ $bookshop__live__iterator__keys = $bookshop__live__iterator__keys | append $i }}{{ end }}`,
         `{{ $bookshop__live__iterator := 0 }}`,
@@ -66,26 +72,26 @@ test("add live markup to loops", t => {
         `{{ $bookshop__live__iterator = (add $bookshop__live__iterator 1) }}`,
         `<p>{{ . }}</p>`,
         `{{ \`<!--bookshop-live unstack-->\` | safeHTML }}`,
-        `{{ end }}`
+        `{{ end }}bookshop`
     ].join('');
     t.is(translateTextTemplate(input, {}), expected);
 });
 
 test("add live markup to loops with iterators", t => {
-    const input = `{{range $loop_index, $element := .columns}}<p>{{$element}}</p>{{ end }}`;
+    const input = `{{range $loop_index, $element := .columns}}<p>{{$element}}</p>{{ end }}bookshop`;
     const expected = [`{{range $loop_index, $element := .columns}}`,
         `{{ \`<!--bookshop-live stack-->\` | safeHTML }}`,
         `{{ (printf \`<!--bookshop-live context(.: (index (.columns) %v))-->\` (jsonify $loop_index)) | safeHTML }}`,
         `<p>{{$element}}</p>`,
         `{{ \`<!--bookshop-live unstack-->\` | safeHTML }}`,
-        `{{ end }}`
+        `{{ end }}bookshop`
     ].join('');
     t.is(translateTextTemplate(input, {}), expected);
 });
 
 test("escape backticks in values", t => {
-    let input = `{{ $a := "hi\`:)" }}`;
-    let expected = `{{ $a := "hi\`:)" }}{{ replace \`<!--bookshop-live context($a: ("hiBKSH_BACKTICK:)"))-->\` "BKSH_BACKTICK" "\`" | safeHTML }}`;
+    let input = `{{ $a := "hi\`:)" }}bookshop`;
+    let expected = `{{ $a := "hi\`:)" }}{{ replace \`<!--bookshop-live context($a: ("hiBKSH_BACKTICK:)"))-->\` "BKSH_BACKTICK" "\`" | safeHTML }}bookshop`;
     t.is(translateTextTemplate(input, {}), expected);
 });
 
@@ -105,7 +111,7 @@ test("add live markup to complex end structures", t => {
         {{end}}
     {{ end }}
 
-{{ end }}`;
+{{ end }}bookshop`;
     const expected = `
 {{ $bookshop__live__iterator__keys := (slice) }}{{ range $i, $e := (.items) }}{{ $bookshop__live__iterator__keys = $bookshop__live__iterator__keys | append $i }}{{ end }}{{ $bookshop__live__iterator := 0 }}{{ range .items }}{{ \`<!--bookshop-live stack-->\` | safeHTML }}{{ $bookshop__live__iterator__key := (index ($bookshop__live__iterator__keys) $bookshop__live__iterator) }}{{ (printf \`<!--bookshop-live context(.: (index (.items) %v))-->\` (jsonify $bookshop__live__iterator__key)) | safeHTML }}{{ $bookshop__live__iterator = (add $bookshop__live__iterator 1) }}
 
@@ -121,7 +127,7 @@ test("add live markup to complex end structures", t => {
         {{ \`<!--bookshop-live unstack-->\` | safeHTML }}{{end}}
     {{ end }}
 
-{{ \`<!--bookshop-live unstack-->\` | safeHTML }}{{ end }}`;
+{{ \`<!--bookshop-live unstack-->\` | safeHTML }}{{ end }}bookshop`;
     t.is(translateTextTemplate(input, {}), expected);
 });
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bookshop/hugo-engine",
   "packageManager": "yarn@3.0.0",
-  "version": "3.3.2",
+  "version": "3.4.0-alpha.2",
   "description": "Bookshop frontend Hugo renderer",
   "type": "module",
   "sideEffects": false,
@@ -14,8 +14,8 @@
     "*.js",
     "lib/*.js",
     "!**/*.test.js",
-    "hugo-renderer/hugo_renderer.wasm",
-    "hugo-renderer/hugo_renderer.wasm.gz"
+    "full-hugo-renderer/hugo_renderer.wasm.gz",
+    "bookshop-hugo-templates/**/*"
   ],
   "scripts": {
     "test": "nyc ava -v"
@@ -30,7 +30,7 @@
     "nyc": "^15.1.0"
   },
   "dependencies": {
-    "@bookshop/helpers": "3.3.2",
+    "@bookshop/helpers": "3.4.0-alpha.2",
     "esbuild": "^0.13.10",
     "fflate": "^0.7.3",
     "liquidjs": "9.28.0"

package/.nyc_output/processinfo/6aec5420-0b83-4260-b300-4d595dfd0660.json

@@ -1 +0,0 @@
-{"parent":null,"pid":3424,"argv":["/opt/hostedtoolcache/node/16.18.1/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":1669766790333,"ppid":3413,"coverageFilename":"/home/runner/work/bookshop/bookshop/javascript-modules/engines/hugo-engine/.nyc_output/6aec5420-0b83-4260-b300-4d595dfd0660.json","externalId":"","uuid":"6aec5420-0b83-4260-b300-4d595dfd0660","files":[]}