@paroicms/site-generator-plugin 0.24.3 → 0.25.0

package/backend/dist/generator/site-generator/common-template-creator.js

@@ -43,7 +43,7 @@ function templateOfSiteLogoTitle(ctx) {
     const content = [
         siteType.fields?.includes("logo")
             ? `{% if site.field.logo %}
-  {% useImage logo image: site.field.logo resize: "50x50" %}
+  {% set logo = image(site.field.logo, resize: "50x50") %}
   <img
     src="{{ logo.url }}"
     width="{{ logo.width }}"
@@ -67,8 +67,8 @@ function templateOfMainMenu(ctx) {
     const menuItems = homeType.routingChildren?.filter((typeName) => typeName !== "search" && typeName !== "searchPage");
     if (!menuItems || menuItems.length === 0)
         return;
-    const itemTemplates = menuItems.map((typeName) => `{% if site.home.${typeName} %}
-  {% assign ${typeName} = site.home.${typeName}.doc %}
+    const itemTemplates = menuItems.map((typeName) => `{% set ${typeName} = doc(site.home.${typeName}) %}
+{% if ${typeName} %}
   <a
     data-menu-item-id="{{ ${typeName}.id }}"
     href="{{ ${typeName}.url }}">
@@ -89,12 +89,9 @@ function templateOfSearchOpener(ctx) {
     if (!typeName)
         return;
     return `<div class="Row center">
-  {% if site.home.${typeName} %}
-    {% assign ${typeName} = site.home.${typeName}.doc %}
-    <span
-      data-effect="paSearchOpener"
-      data-search-url="{{ ${typeName}.url }}"
-      data-icon-color="#fff"></span>
+  {% set ${typeName} = doc(site.home.${typeName}) %}
+  {% if ${typeName} %}
+    {% out searchOpener(url: ${typeName}.url, iconColor: "#fff") %}
   {% endif %}
   <div data-mobile-menu="button"></div>
 </div>`;

package/backend/dist/generator/site-generator/document-card-template-creator.js

@@ -0,0 +1,40 @@
+import { getJtRegularDocumentType, getPossibleJtLabelingFieldTypes, } from "./jt-site-schema-helpers.js";
+import { indent } from "./template-helpers.js";
+export function templateOfDocumentCard(ctx, docVariableName, { parentType } = {}) {
+    const { siteSchema } = ctx;
+    const possibleTypes = parentType
+        ? (parentType.regularChildren ?? []).map((childName) => getJtRegularDocumentType(siteSchema, childName))
+        : undefined;
+    const labelingFields = getPossibleJtLabelingFieldTypes(siteSchema, possibleTypes);
+    const labelingTemplates = labelingFields.map((field) => {
+        const fieldName = ` ${docVariableName}.field.${field.name}`;
+        return `{% if ${fieldName} %}
+  <ul class="FlexWrap">
+    {% for labelDoc in ${fieldName} %}
+      <li class="Label">{{ labelDoc.title }}</li>
+    {% endfor %}
+  </ul>
+{% endif %}`;
+    });
+    return `<a href="{{ ${docVariableName}.url }}">
+  <article>
+    {% if ${docVariableName}.defaultImage %}
+      <div>
+        {% set im = image(${docVariableName}.defaultImage, resize: "120x120") %}
+        <img
+          src="{{ im.url }}"
+          width="{{ im.width }}"
+          height="{{ im.height }}"
+          loading="lazy"
+          alt=""
+        >
+      </div>
+    {% endif %}
+    <div>
+      <h3>{{ ${docVariableName}.title }}</h3>
+      <p>{{ ${docVariableName}.excerpt | makeExcerpt: 40 }}</p>
+      ${indent(labelingTemplates.join("\n"), 3, { skipFirst: true })}
+    </div>
+  </article>
+</a>`;
+}

package/backend/dist/generator/site-generator/document-template-creator.js

@@ -1,8 +1,10 @@
 import { isDef } from "@paroicms/public-anywhere-lib";
 import { camelToKebabCase } from "../lib/utils.js";
 import { templateOfDocumentBreadcrumb } from "./common-template-creator.js";
+import { templateOfDocumentCard } from "./document-card-template-creator.js";
 import { createIdKeyProvider } from "./id-key-provider.js";
-import { getJtPartType, getJtRegularDocumentType, getJtRoutingDocumentType, getPossibleJtLabelingFieldTypes, hasTemporalChildren, } from "./jt-site-schema-helpers.js";
+import { getJtPartType, getJtRoutingDocumentType, hasTemporalChildren, } from "./jt-site-schema-helpers.js";
+import { templatesOfLabeledList } from "./labeled-list-template-creator.js";
 import { getPredefinedDataType, indent, localizedLabelTemplate } from "./template-helpers.js";
 export function templateOfDocumentType(ctx, documentType) {
     const childrenTemplate = templateOfDocumentChildren(ctx, documentType, createIdKeyProvider());
@@ -16,26 +18,20 @@ export function templateOfDocumentType(ctx, documentType) {
         ?.map((list) => templateOfList(ctx, list, { listKey: `doc.list.${list.listName}`, nested: false }))
         .filter(isDef) ?? [];
     const specialTemplate = templateOfSpecialDocument(ctx, documentType);
+    const labeledListTemplates = templatesOfLabeledList(ctx, documentType);
     ctx.addLiquidFile("partials", "breadcrumb.liquid", templateOfDocumentBreadcrumb(), {
         skipIfExists: true,
     });
     const blocks = [
-        `{% render "partials/breadcrumb" doc: doc site: site %}`,
+        `{% render "partials/breadcrumb" doc: doc %}`,
         featuredImageTemplate,
         titleFieldsTemplate,
-        childrenTemplate,
         specialTemplate,
         ...listTemplates,
+        ...labeledListTemplates,
+        childrenTemplate,
     ].filter(isDef);
-    const notOK = blocks.filter((f) => typeof f !== "string" || f === "false");
-    if (notOK.length > 0) {
-        console.log("......................BUG", notOK);
-        console.log("......................titleFieldsTemplate", titleFieldsTemplate);
-        console.log("......................childrenTemplate", childrenTemplate);
-        console.log("......................specialTemplate", specialTemplate);
-        console.log("......................listTemplates", listTemplates);
-    }
-    return `{% layout "layouts/main-layout.liquid" doc: doc site: site %}
+    return `{% layout "layouts/main-layout.liquid" %}
 {% block %}
 ${blocks.join("\n\n")}
 {% endblock %}`;
@@ -49,7 +45,7 @@ function templateOfTitleAndFields(ctx, documentType) {
     const textBlock = `<div class="TextWidth">
   ${indent(blocks1.join("\n"), 1, { skipFirst: true })}
 </div>`;
-    const siblingsTemplate = documentType.documentKind === "regular" && templateOfSiblingLinks(ctx);
+    const siblingsTemplate = documentType.documentKind === "regular" ? templateOfSiblingLinks(ctx) : undefined;
     const blocks2 = [textBlock, siblingsTemplate].filter(isDef);
     return `<div class="_bg2">
   <div class="Container">
@@ -63,19 +59,18 @@ function templateOfSpecialDocument(ctx, documentType) {
     const { addLiquidFile } = ctx;
     if (documentType.typeName === "search" || documentType.typeName === "searchPage") {
         addLiquidFile("partials", "result-item.public.liquid", templateOfDocumentCard(ctx, "doc"));
-        return `<div
-  class="Container"
-  data-effect="paSearchApp"
-  data-template="result-item"
-  data-limit="10"></div>`;
+        return `<div class="Container">
+  <div class="Page">
+    {% out searchApp(class: "Container", template: "partials/result-item.public", by: 10) %}
+  </div>
+</div>`;
     }
     if (documentType.typeName === "contact" || documentType.typeName === "contactPage") {
         return `<div class="Container">
-  <div class="TextWidth Pt">
-    <div
-      data-effect="paContactForm"
-      data-home-url="{{ site.home.url }}"
-    ></div>
+  <div class="Page">
+    <div class="TextWidth Pt">
+      {% out contactForm %}
+    </div>
   </div>
 </div>`;
     }
@@ -113,8 +108,8 @@ function templateOfRoutingChild(ctx, child, parentIdKeyProvider) {
     const idKeyProvider = parentIdKeyProvider.createForRoutingChild(typeName);
     const key = idKeyProvider.key;
     if (!hasTemporalChildren(siteSchema, child) || regularChildrenSorting !== "publishDate desc") {
-        const buttonTemplate = `{% if ${key} %}
-  {% assign ${variableName} = ${key}.doc %}
+        const buttonTemplate = `{% set ${variableName} = doc(${key}) %}
+{% if ${variableName} %}
   <a class="Button" href="{{ ${variableName}.url }}">{{ ${variableName}.title }}</a>
 {% endif %}`;
         return buttonTemplate;
@@ -122,8 +117,8 @@ function templateOfRoutingChild(ctx, child, parentIdKeyProvider) {
     const cardsTemplate = templateOfRegularDocumentCards(ctx, child, idKeyProvider, {
         mode: "sampleOnly",
     });
-    return `{% if ${key} %}
-  {% assign ${variableName} = ${key}.doc %}
+    return `{% set ${variableName} = doc(${key}) %}
+{% if ${variableName} %}
   <div class="Pt">
     <h2>
       <a class="TextLink" href="{{ ${variableName}.url }}">{{ ${variableName}.title }}</a>
@@ -137,9 +132,9 @@ function templateOfRegularDocumentCards(ctx, parentType, parentIdKeyProvider, {
     const { typeName: parentTypeName } = parentType;
     const childrenVariableName = `${parentTypeName}Children`;
     const childVariableName = `${parentTypeName}Child`;
-    const idKey = parentIdKeyProvider.idKey;
+    const key = parentIdKeyProvider.key;
     if (mode === "sampleOnly") {
-        return `{% getDocs ${childrenVariableName} parentId: ${idKey} limit: 4 %}
+        return `{% set ${childrenVariableName} = docs(${key}.children, limit: 4) %}
 <div class="List">
   {% for ${childVariableName} in ${childrenVariableName} %}
     ${indent(templateOfDocumentCard(ctx, childVariableName, { parentType }), 2, { skipFirst: true })}
@@ -147,30 +142,18 @@ function templateOfRegularDocumentCards(ctx, parentType, parentIdKeyProvider, {
 </div>`;
     }
     if (!hasTemporalChildren(siteSchema, parentType)) {
-        return `{% getDocs ${childrenVariableName} parentId: ${idKey} %}
+        return `{% set ${childrenVariableName} = docs(${key}.children) %}
   <div class="Container List Pt Pb">
   {% for ${childVariableName} in ${childrenVariableName} %}
     ${indent(templateOfDocumentCard(ctx, childVariableName, { parentType }), 2, { skipFirst: true })}
   {% endfor %}
 </div>`;
     }
-    const cardTemplateName = `${camelToKebabCase(parentTypeName)}-card`;
-    addLiquidFile("partials", `${cardTemplateName}.public.liquid`, templateOfDocumentCard(ctx, "doc", { parentType }));
-    return `{% getPaginatedDocs ${childrenVariableName} parentId: ${idKey} pageSize: 10 %}
+    const cardTemplateName = `${camelToKebabCase(parentTypeName)}-card.public`;
+    addLiquidFile("partials", `${cardTemplateName}.liquid`, templateOfDocumentCard(ctx, "doc", { parentType }), { skipIfExists: true });
+    return `{% set ${childrenVariableName} = paginatedDocs(${key}.children, by: 10) %}
 <div class="Container">
-  <div
-    class="Page List"
-    data-effect="paInfiniteLoading"
-    data-parent-id="{{ ${idKey} }}"
-    data-start="{{ ${childrenVariableName}.pageSize }}"
-    data-limit="{{ ${childrenVariableName}.pageSize }}"
-    data-total="{{ ${childrenVariableName}.total }}"
-    data-template="${cardTemplateName}"
-  >
-    {% for ${childrenVariableName} in ${childrenVariableName}.items %}
-      {% render "partials/${cardTemplateName}.public.liquid" doc: ${childrenVariableName} %}
-    {% endfor %}
-  </div>
+  {% out infiniteLoading(class: "Page List", paginatedDocs: ${childrenVariableName}, template: "partials/${cardTemplateName}") %}
 </div>`;
 }
 function templateOfFields(ctx, fields, { parentKey }) {
@@ -214,7 +197,7 @@ function templateOfField(ctx, fieldOrName, parentKey) {
     if (dataType === "gallery") {
         return `<div class="Field">
   {% for media in ${parentKey}.${fieldName} %}
-    {% useImage im image: media resize: "150x150" %}
+    {% set im = image(media, resize: "150x150") %}
     <img
       class="Field-img"
       src="{{ im.url }}"
@@ -229,7 +212,7 @@ function templateOfField(ctx, fieldOrName, parentKey) {
     }
     if (dataType === "media") {
         const mediaKey = `${parentKey}.${fieldName}`;
-        return `{% useImage im image: ${mediaKey} resize: "x250x" %}
+        return `{% set im = image(${mediaKey}, resize: "x250x") %}
 <div class="Field">
   <img
     class="Field-img"
@@ -249,8 +232,8 @@ function templateOfField(ctx, fieldOrName, parentKey) {
 }
 function templateOfPicture({ imageKey }) {
     return `{% if ${imageKey} %}
-  {% useImage smallIm image: ${imageKey} resize: "360x48" %}
-  {% useImage largeIm image: ${imageKey} resize: "1200x160" %}
+  {% set smallIm = image(${imageKey}, resize: "360x48") %}
+  {% set largeIm = image(${imageKey}, resize: "1200x160") %}
   <div class="Container">
     <picture class="Hero">
       <source
@@ -333,51 +316,15 @@ function templateOfSiblingLinks(ctx) {
         fr: "Suivant",
     });
     return `<div class="Row spaceBetween">
-  {% if doc.siblings.previous %}
-    <a href="{{ doc.siblings.previous.url }}" title="{{ doc.siblings.previous.title }}">← ${previousLabelTemplate}</a>
+  {% set previous = doc(doc.siblings.previous) %}
+  {% if previous %}
+    <a href="{{ previous.url }}" title="{{ previous.title }}">← ${previousLabelTemplate}</a>
   {% else %}
     <span></span>
   {% endif %}
-  {% if doc.siblings.next %}
-    <a href="{{ doc.siblings.next.url }}" title="{{ doc.siblings.next.title }}">${nextLabelTemplate} →</a>
+  {% set next = doc(doc.siblings.next) %}
+  {% if next %}
+    <a href="{{ next.url }}" title="{{ next.title }}">${nextLabelTemplate} →</a>
   {% endif %}
 </div>`;
 }
-function templateOfDocumentCard(ctx, docVariableName, { parentType } = {}) {
-    const { siteSchema } = ctx;
-    const possibleTypes = parentType
-        ? (parentType.regularChildren ?? []).map((childName) => getJtRegularDocumentType(siteSchema, childName))
-        : undefined;
-    const labelingFields = getPossibleJtLabelingFieldTypes(siteSchema, possibleTypes);
-    const labelingTemplates = labelingFields.map((field) => {
-        const fieldName = ` ${docVariableName}.field.${field.name}`;
-        return `{% if ${fieldName} %}
-  <ul class="FlexWrap">
-    {% for labelDoc in ${fieldName} %}
-      <li class="Label">{{ labelDoc.title }}</li>
-    {% endfor %}
-  </ul>
-{% endif %}`;
-    });
-    return `<a href="{{ ${docVariableName}.url }}">
-  <article>
-    {% if ${docVariableName}.defaultImage %}
-      <div>
-        {% useImage im image: ${docVariableName}.defaultImage resize: "120x120" %}
-        <img
-          src="{{ im.url }}"
-          width="{{ im.width }}"
-          height="{{ im.height }}"
-          loading="lazy"
-          alt=""
-        >
-      </div>
-    {% endif %}
-    <div>
-      <h3>{{ ${docVariableName}.title }}</h3>
-      <p>{{ ${docVariableName}.excerpt | makeExcerpt: 40 }}</p>
-      ${indent(labelingTemplates.join("\n"), 3, { skipFirst: true })}
-    </div>
-  </article>
-</a>`;
-}

package/backend/dist/generator/site-generator/id-key-provider.js

@@ -1,6 +1,6 @@
 export function createIdKeyProvider() {
     return {
-        key: "doc",
+        key: "doc.routing",
         idKey: "doc.id",
         getChildRoutingKey: (typeName) => `doc.routing.${typeName}`,
         createForRoutingChild: (routingTypeName) => createChildIdKeyProvider(`doc.routing.${routingTypeName}`),

package/backend/dist/generator/site-generator/labeled-list-template-creator.js

@@ -0,0 +1,56 @@
+import { isDef } from "@paroicms/public-anywhere-lib";
+import { camelToKebabCase } from "../lib/utils.js";
+import { templateOfDocumentCard } from "./document-card-template-creator.js";
+export function templatesOfLabeledList(ctx, documentType) {
+    const { addLiquidFile } = ctx;
+    const labeledByUs = ctx.labeledDocuments.filter((doc) => {
+        const parentTypes = ctx.getParentTypes(documentType);
+        return parentTypes.some((parentType) => parentType.typeName === doc.taxonomyType.typeName);
+    });
+    return labeledByUs
+        .map((labeledDocument) => {
+        const parentRoutingKey = getRoutingKeyInCluster(ctx, labeledDocument.parentDocumentType, {
+            sameClusterAs: labeledDocument.taxonomyType,
+        });
+        if (!parentRoutingKey)
+            return;
+        const labeledListKey = `labeled${upperCaseFirstLetter(labeledDocument.parentDocumentType.typeName)}`;
+        const cardTemplateName = `${camelToKebabCase(labeledDocument.documentType.typeName)}-card.public`;
+        addLiquidFile("partials", `${cardTemplateName}.liquid`, templateOfDocumentCard(ctx, "doc", { parentType: labeledDocument.parentDocumentType }), { skipIfExists: true });
+        return `{% set ${labeledListKey} = paginatedDocs(${parentRoutingKey}.children, by: 10, term: doc, labeledWith: "${labeledDocument.field.name}") %}
+<div class="Container">
+  {% out infiniteLoading(class: "Page List", paginatedDocs: ${labeledListKey}, template: "partials/${cardTemplateName}") %}
+</div>`;
+    })
+        .filter(isDef);
+}
+function upperCaseFirstLetter(str) {
+    return `${str.charAt(0).toUpperCase()}${str.slice(1)}`;
+}
+function getRoutingKeyInCluster(ctx, documentType, options) {
+    const { siteSchema } = ctx;
+    const { nodeTypes } = siteSchema;
+    if (!nodeTypes)
+        return;
+    const getNodeType = (typeName) => nodeTypes.find((nt) => nt.typeName === typeName);
+    function findPath(target, current, parentPath) {
+        const currentPath = [...parentPath, current];
+        if (current === target)
+            return currentPath;
+        const node = getNodeType(current);
+        if (!node || node.kind !== "document" || !node.routingChildren)
+            return;
+        for (const childName of node.routingChildren) {
+            const found = findPath(target, childName, currentPath);
+            if (found)
+                return found;
+        }
+    }
+    const clusterRootTypeName = "home"; // limitation here: only works for the "home" cluster
+    const targetPath = findPath(documentType.typeName, clusterRootTypeName, []);
+    const sameClusterPath = findPath(options.sameClusterAs.typeName, clusterRootTypeName, []);
+    if (!targetPath || !sameClusterPath)
+        return;
+    targetPath.shift(); // remove leading 'home'
+    return `doc.cluster.routing.${targetPath.join(".")}`;
+}

package/backend/dist/generator/site-generator/theme-creator-context.js

@@ -0,0 +1,109 @@
+import { getPredefinedFields } from "../lib/create-prompt.js";
+export function createThemeCreatorContext(siteSchema) {
+    const languages = siteSchema.languages ?? [];
+    const liquidFiles = new Map();
+    const localeFiles = new Map();
+    const otherFiles = new Map();
+    const issues = [];
+    const getParentTypes = makeGetParentTypes(siteSchema);
+    return {
+        siteSchema,
+        labeledDocuments: getLabeledDocuments(siteSchema, getParentTypes),
+        getParentTypes,
+        predefinedFields: new Map(getPredefinedFields().map((f) => [f.fieldName, f])),
+        setLocalizedLabel(label) {
+            for (const language of languages) {
+                const value = label[language];
+                if (!value)
+                    continue;
+                let f = localeFiles.get(language);
+                if (!f) {
+                    f = {};
+                    localeFiles.set(language, f);
+                }
+                f[language] = value;
+            }
+        },
+        hasLiquidFile(directory, filename) {
+            const path = directory === "root" ? `templates/${filename}` : `templates/${directory}/${filename}`;
+            return liquidFiles.has(path);
+        },
+        addLiquidFile(directory, filename, content, { skipIfExists = false } = {}) {
+            const path = directory === "root" ? `templates/${filename}` : `templates/${directory}/${filename}`;
+            if (liquidFiles.has(path)) {
+                if (skipIfExists)
+                    return;
+                issues.push(`Liquid file already exists, overwrite: "${path}"`);
+            }
+            liquidFiles.set(path, content);
+        },
+        addFile(path, content) {
+            if (otherFiles.has(path))
+                throw new Error(`File already exists: "${path}"`);
+            otherFiles.set(path, content);
+        },
+        toFiles() {
+            const files = [
+                ...Array.from(liquidFiles.entries()).map(([path, content]) => ({ path, content })),
+                ...Array.from(localeFiles.entries()).map(([language, content]) => ({
+                    path: `locales/${language}.json`,
+                    content: JSON.stringify(content, null, 2),
+                })),
+                ...Array.from(otherFiles.entries()).map(([path, content]) => ({ path, content })),
+            ];
+            files.sort((a, b) => a.path.localeCompare(b.path));
+            return { files, issues: issues.length > 0 ? issues : undefined };
+        },
+    };
+}
+function makeGetParentTypes(siteSchema) {
+    const parentsByChild = new Map();
+    const nodeTypes = siteSchema.nodeTypes ?? [];
+    for (const type of nodeTypes) {
+        if (type.kind !== "document")
+            continue;
+        if (type.documentKind === "routing") {
+            for (const childName of type.routingChildren ?? []) {
+                const list = parentsByChild.get(childName) ?? [];
+                list.push(type);
+                parentsByChild.set(childName, list);
+            }
+        }
+        for (const childName of type.regularChildren ?? []) {
+            const list = parentsByChild.get(childName) ?? [];
+            list.push(type);
+            parentsByChild.set(childName, list);
+        }
+    }
+    return (documentType) => parentsByChild.get(documentType.typeName) ?? [];
+}
+function getLabeledDocuments(siteSchema, getParentTypes) {
+    const result = [];
+    for (const documentType of siteSchema.nodeTypes ?? []) {
+        if (documentType.kind !== "document" || documentType.documentKind !== "regular")
+            continue;
+        for (const field of documentType.fields ?? []) {
+            if (typeof field === "string" || field.storedAs !== "labeling")
+                continue;
+            const taxonomyType = siteSchema.nodeTypes?.find((nt) => nt.typeName === field.taxonomy);
+            if (!taxonomyType ||
+                taxonomyType.kind !== "document" ||
+                taxonomyType.documentKind !== "routing") {
+                continue;
+            }
+            for (const parentDocumentType of getParentTypes(documentType)) {
+                if (parentDocumentType.kind !== "document" ||
+                    parentDocumentType.documentKind !== "routing") {
+                    continue;
+                }
+                result.push({
+                    documentType,
+                    parentDocumentType,
+                    field,
+                    taxonomyType,
+                });
+            }
+        }
+    }
+    return result;
+}

package/backend/dist/generator/site-generator/theme-creator.js

@@ -1,11 +1,11 @@
 import { isObj } from "@paroicms/public-anywhere-lib";
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { getPredefinedFields } from "../lib/create-prompt.js";
 import { camelToKebabCase } from "../lib/utils.js";
 import { templateOfSiteFooter, templateOfSiteHeader } from "./common-template-creator.js";
 import { templateOfDocumentType } from "./document-template-creator.js";
 import { isMultilingual } from "./jt-site-schema-helpers.js";
+import { createThemeCreatorContext } from "./theme-creator-context.js";
 import { getThemeCssContent } from "./theme-css.js";
 export async function createTheme(ctx, siteDir, siteSchema) {
     const themeContext = createThemeCreatorContext(siteSchema);
@@ -38,70 +38,6 @@ export async function createTheme(ctx, siteDir, siteSchema) {
         ctx.logger.warn(`Issues in "${siteDir}":`, issues);
     }
 }
-function createThemeCreatorContext(siteSchema) {
-    const languages = siteSchema.languages ?? [];
-    const liquidFiles = new Map();
-    const localeFiles = new Map();
-    const otherFiles = new Map();
-    const issues = [];
-    return {
-        siteSchema,
-        predefinedFields: new Map(getPredefinedFields().map((f) => [f.fieldName, f])),
-        setLocalizedLabel(label) {
-            for (const language of languages) {
-                const value = label[language];
-                if (!value)
-                    continue;
-                let f = localeFiles.get(language);
-                if (!f) {
-                    f = {};
-                    localeFiles.set(language, f);
-                }
-                f[language] = value;
-            }
-        },
-        hasLiquidFile(directory, filename) {
-            const path = directory === "root" ? `templates/${filename}` : `templates/${directory}/${filename}`;
-            return liquidFiles.has(path);
-        },
-        addLiquidFile(directory, filename, content, { skipIfExists = false } = {}) {
-            const path = directory === "root" ? `templates/${filename}` : `templates/${directory}/${filename}`;
-            if (liquidFiles.has(path)) {
-                if (skipIfExists)
-                    return;
-                issues.push(`Liquid file already exists, overwrite: "${path}"`);
-            }
-            liquidFiles.set(path, content);
-        },
-        addFile(path, content) {
-            if (otherFiles.has(path))
-                throw new Error(`File already exists: "${path}"`);
-            otherFiles.set(path, content);
-        },
-        toFiles() {
-            const files = [
-                ...Array.from(liquidFiles.entries()).map(([path, content]) => ({ path, content })),
-                ...Array.from(localeFiles.entries()).map(([language, content]) => ({
-                    path: `locales/${language}.json`,
-                    content: JSON.stringify(content, null, 2),
-                })),
-                ...Array.from(otherFiles.entries()).map(([path, content]) => ({ path, content })),
-            ];
-            files.sort((a, b) => a.path.localeCompare(b.path));
-            return { files, issues: issues.length > 0 ? issues : undefined };
-        },
-    };
-}
-// function getDefaultLiquidContent() {
-//   return `{% layout "layouts/main-layout.liquid" doc: doc site: site %}
-// {% block %}
-// <div class="Container">
-//   <div class="Page">
-//     {{ doc | info }}
-//   </div>
-// </div>
-// {% endblock %}`;
-// }
 function templateOf404(ctx) {
     const { siteSchema } = ctx;
     const rawParam = isMultilingual(siteSchema) ? " raw: true" : "";
@@ -132,13 +68,13 @@ function templateOfLayout(ctx) {
     const multilingual = isMultilingual(siteSchema);
     ctx.addLiquidFile("partials", "site-header.liquid", templateOfSiteHeader(ctx));
     ctx.addLiquidFile("partials", "site-footer.liquid", templateOfSiteFooter(ctx));
-    const renderHeader = `{% render "partials/site-header" doc: doc site: site %}`;
+    const renderHeader = `{% render "partials/site-header" doc: doc %}`;
     const headerTemplate = multilingual
         ? `{% unless raw %}
   ${renderHeader}
 {% endunless %}`
         : renderHeader;
-    const renderFooter = `{% render "partials/site-footer" doc: doc site: site %}`;
+    const renderFooter = `{% render "partials/site-footer" doc: doc %}`;
     const footerTemplate = multilingual
         ? `{% unless raw %}
   ${renderFooter}

package/backend/dist/index.js

@@ -43,12 +43,12 @@ const plugin = {
             startSiteRemover(rawContext);
         });
         service.setPublicAssetsDirectory(join(packageDir, "frontend", "dist"));
-        service.registerLiquidTag("siteGeneratorApp", "injectHtml", (service) => {
-            service.setRenderState("paSiteGeneratorApp", true);
+        service.registerOutLiquidTagFunction("siteGeneratorApp", (service) => {
+            service.setRenderState("siteGeneratorApp", true);
             return `<div id="site-generator-app"></div>`;
-        });
+        }, { raw: true });
         service.registerHeadTags(({ state }) => {
-            if (!state.get("paSiteGeneratorApp"))
+            if (!state.get("siteGeneratorApp"))
                 return;
             return [
                 makeStylesheetLinkAsyncTag(`${service.pluginAssetsUrl}/frontend.css`),