@paroicms/site-generator-plugin 0.24.2 → 0.25.0

package/backend/dist/generator/fake-content-generator/create-node-contents.js

@@ -150,13 +150,24 @@ function getDefaultStringValueForField(fieldName) {
     return undefined;
 }
 export function generateLocalizedFooterMention(siteSchema) {
-    const { languages, languageLabels } = siteSchema;
+    const { languages } = siteSchema;
     return Object.fromEntries(languages.map((language) => [
         language,
         {
             j: {
-                ops: markdownToDelta(`Powered by ParoiCMS in ${languageLabels[language]}`),
+                ops: markdownToDelta(getPoweredByLabel(language)),
             },
         },
     ]));
 }
+function getPoweredByLabel(language) {
+    const translations = {
+        en: "Powered by ParoiCMS",
+        fr: "Propulsé par ParoiCMS",
+        es: "Desarrollado por ParoiCMS",
+        de: "Betrieben von ParoiCMS",
+        it: "Alimentato da ParoiCMS",
+        pt: "Desenvolvido por ParoiCMS",
+    };
+    return translations[language] ?? translations.en;
+}

package/backend/dist/generator/fake-content-generator/generate-fake-content.js

@@ -1,3 +1,4 @@
+import { isDef, } from "@paroicms/public-anywhere-lib";
 import { camelToKebabCase, camelToTitleCase } from "../lib/utils.js";
 import { createNodeContents } from "./create-node-contents.js";
 import { invokeGenerateFakeContent, } from "./invoke-generate-fake-content.js";
@@ -20,7 +21,7 @@ export async function generateMultipleFieldSetContents(ctx, options, report) {
         ? [{ tagName: "title", key: "title", format: "text", tagDescription: "Write the title here" }]
         : [];
     if (nodeType.fields) {
-        outputTags.push(...nodeType.fields.map(toFakeContentOutputTag).filter(Boolean));
+        outputTags.push(...nodeType.fields.map(toFakeContentOutputTag).filter(isDef));
     }
     const defaultLanguage = siteSchema.languages?.[0];
     const typeLabel = translateText(schemaI18n, `nodeTypes.${nodeType.typeName}.label`, {

package/backend/dist/generator/lib/calling-llm-mistral.js

@@ -1,11 +1,11 @@
-import { messageOf } from "@paroicms/public-anywhere-lib";
+import { isDef, messageOf } from "@paroicms/public-anywhere-lib";
 let seq = 0;
 export async function batchInvokeMinistral(ctx, prompts, options) {
     const startTime = Date.now();
     const responses = await execBatchInvokeMinistral(ctx, prompts, options);
     const llmMessages = responses
         .map((msg) => msg.response.body.choices[0]?.message.content)
-        .filter(Boolean);
+        .filter(isDef);
     const llmReport = {
         llmTaskName: options.llmTaskName,
         modelName: ctx.mistralModelName,

package/backend/dist/generator/lib/debug-utils.js

@@ -1,5 +1,5 @@
 import { ensureDirectory } from "@paroicms/internal-server-lib";
-import { isObj, messageOf } from "@paroicms/public-anywhere-lib";
+import { isDef, isObj, messageOf } from "@paroicms/public-anywhere-lib";
 import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { estimateTokenCount } from "./llm-tokens.js";
@@ -112,7 +112,7 @@ async function writeDebugLlmInputOutputs(ctx, stepHandle, list, llmReport, start
         stepHandle?.stepNumber,
         llmReport.llmTaskName,
         llmReport.errorMessage ? "ERROR" : undefined,
-    ].filter(Boolean);
+    ].filter(isDef);
     const baseName = nameParts.join("-");
     const header = [
         `Model: ${llmReport.modelName}`,

package/backend/dist/generator/llm-queries/invoke-new-site-analysis.js

@@ -1,3 +1,4 @@
+import { isDef } from "@paroicms/public-anywhere-lib";
 import { loadStep } from "../../db/db-read.queries.js";
 import { insertStep, saveCompletedSchemaStep, updateStep, } from "../../db/db-write.queries.js";
 import { reorderObjectKeys } from "../helpers/js-utils.js";
@@ -210,7 +211,7 @@ function createUnusedInformationPrompt(unusedInformation, analysis) {
         .map(([typeName, entry]) => {
         return entry.prompt ? `${typeName}: ${entry.prompt}` : undefined;
     })
-        .filter(Boolean);
+        .filter(isDef);
     if (prompts.length > 0) {
         const nodeTypePrompts = `To do:\n\n- ${prompts.join("- \n")}`;
         return unusedInformation ? `${nodeTypePrompts}\n\n${unusedInformation}` : nodeTypePrompts;

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

@@ -1,3 +1,4 @@
+import { isDef } from "@paroicms/public-anywhere-lib";
 import { getJtHomeType, getJtSiteType, isMultilingual } from "./jt-site-schema-helpers.js";
 import { indent } from "./template-helpers.js";
 export function templateOfDocumentBreadcrumb() {
@@ -24,7 +25,7 @@ export function templateOfSiteHeader(ctx) {
     ];
     return `<div class="_bg2">
   <header class="Container Header">
-    ${indent(content.filter(Boolean).join("\n"), 2, { skipFirst: true })}
+    ${indent(content.filter(isDef).join("\n"), 2, { skipFirst: true })}
   </header>
 </div>
 <div
@@ -42,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 }}"
@@ -57,7 +58,7 @@ function templateOfSiteLogoTitle(ctx) {
   class="Header-logo"
   href="{{ site.home.url }}"
   data-mobile-menu-part="logo">
-  ${indent(content.filter(Boolean).join("\n"), 1, { skipFirst: true })}
+  ${indent(content.filter(isDef).join("\n"), 1, { skipFirst: true })}
 </a>`;
 }
 function templateOfMainMenu(ctx) {
@@ -66,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 }}">
@@ -88,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>`;
@@ -102,7 +100,7 @@ export function templateOfSiteFooter(ctx) {
     const content = [templateOfSiteFooterMention(ctx), templateOfLanguageSelector(ctx)];
     return `<div class="_bg2">
   <footer class="Container">
-    ${indent(content.filter(Boolean).join("\n"), 2, { skipFirst: true })}
+    ${indent(content.filter(isDef).join("\n"), 2, { skipFirst: true })}
   </footer>
 </div>`;
 }
@@ -120,10 +118,11 @@ function templateOfLanguageSelector(ctx) {
     return `<ul class="LanguageSelector">
   {% for translation in doc.translations %}
     <li>
-      <a
-        class="{% if translation.active %}active{% endif %}"
-        href="{{ translation.url }}"
-        title="{{ translation.languageLabel }}">{{ translation.language }}</a>
+      {% if translation.active %}
+        <span>{{ translation.languageLabel }}</span>
+      {% else %}
+        <a href="{{ translation.url }}">{{ translation.languageLabel }}</a>
+      {% endif %}
     </li>
   {% endfor %}
 </ul>`;

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,7 +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, 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());
@@ -11,20 +14,24 @@ export function templateOfDocumentType(ctx, documentType) {
         })
         : undefined;
     const titleFieldsTemplate = templateOfTitleAndFields(ctx, documentType);
-    const listTemplates = documentType.lists?.map((list) => templateOfList(ctx, list, { listKey: `doc.list.${list.listName}`, nested: false })) ?? [];
+    const listTemplates = documentType.lists
+        ?.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,
-    ].filter(Boolean);
-    return `{% layout "layouts/main-layout.liquid" doc: doc site: site %}
+        ...labeledListTemplates,
+        childrenTemplate,
+    ].filter(isDef);
+    return `{% layout "layouts/main-layout.liquid" %}
 {% block %}
 ${blocks.join("\n\n")}
 {% endblock %}`;
@@ -38,8 +45,8 @@ 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 blocks2 = [textBlock, siblingsTemplate].filter(Boolean);
+    const siblingsTemplate = documentType.documentKind === "regular" ? templateOfSiblingLinks(ctx) : undefined;
+    const blocks2 = [textBlock, siblingsTemplate].filter(isDef);
     return `<div class="_bg2">
   <div class="Container">
     <div class="Page">
@@ -51,31 +58,31 @@ function templateOfTitleAndFields(ctx, documentType) {
 function templateOfSpecialDocument(ctx, documentType) {
     const { addLiquidFile } = ctx;
     if (documentType.typeName === "search" || documentType.typeName === "searchPage") {
-        addLiquidFile("partials", "result-item.public.liquid", templateOfDocumentTile("doc"));
-        return `<div
-  class="Container"
-  data-effect="paSearchApp"
-  data-template="result-item"
-  data-limit="10"></div>`;
+        addLiquidFile("partials", "result-item.public.liquid", templateOfDocumentCard(ctx, "doc"));
+        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>`;
     }
 }
 function templateOfDocumentChildren(ctx, parentType, parentIdKeyProvider) {
     const routingBlocks = templateOfRoutingChildren(ctx, parentType, parentIdKeyProvider);
-    const regularBlocks = parentType.documentKind === "routing" &&
-        parentType.regularChildren &&
-        templateOfRegularDocumentTiles(ctx, parentType, parentIdKeyProvider, {
+    const regularBlocks = parentType.documentKind === "routing" && parentType.regularChildren
+        ? templateOfRegularDocumentCards(ctx, parentType, parentIdKeyProvider, {
             mode: "all",
-        });
-    return [routingBlocks, regularBlocks].filter(Boolean).join("\n\n") || undefined;
+        })
+        : undefined;
+    return [routingBlocks, regularBlocks].filter(isDef).join("\n\n") || undefined;
 }
 function templateOfRoutingChildren(ctx, parentType, parentIdKeyProvider) {
     const { siteSchema } = ctx;
@@ -87,7 +94,7 @@ function templateOfRoutingChildren(ctx, parentType, parentIdKeyProvider) {
         }
         return templateOfRoutingChild(ctx, child, parentIdKeyProvider);
     })
-        .filter(Boolean);
+        .filter(isDef);
     if (routingBlocks.length === 0)
         return;
     return `<div class="Container">
@@ -101,63 +108,52 @@ 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;
     }
-    const tilesTemplate = templateOfRegularDocumentTiles(ctx, child, idKeyProvider, {
+    const cardsTemplate = templateOfRegularDocumentCards(ctx, child, idKeyProvider, {
         mode: "sampleOnly",
     });
-    return `{% if ${key} %}
-{% assign ${variableName} = ${key}.doc %}
-<div class="Pt">
-  <h2>
-    <a class="TextLink" href="{{ ${variableName}.url }}">{{ ${variableName}.title }}</a>
-  </h2>
-  ${indent(tilesTemplate, 1, { skipFirst: true })}
-</div>
+    return `{% set ${variableName} = doc(${key}) %}
+{% if ${variableName} %}
+  <div class="Pt">
+    <h2>
+      <a class="TextLink" href="{{ ${variableName}.url }}">{{ ${variableName}.title }}</a>
+    </h2>
+    ${indent(cardsTemplate, 2, { skipFirst: true })}
+  </div>
 {% endif %}`;
 }
-function templateOfRegularDocumentTiles(ctx, parentType, parentIdKeyProvider, { mode }) {
+function templateOfRegularDocumentCards(ctx, parentType, parentIdKeyProvider, { mode }) {
     const { siteSchema, addLiquidFile } = ctx;
     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(templateOfDocumentTile(childVariableName), 2, { skipFirst: true })}
+    ${indent(templateOfDocumentCard(ctx, childVariableName, { parentType }), 2, { skipFirst: true })}
   {% endfor %}
 </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(templateOfDocumentTile(childVariableName), 2, { skipFirst: true })}
+    ${indent(templateOfDocumentCard(ctx, childVariableName, { parentType }), 2, { skipFirst: true })}
   {% endfor %}
 </div>`;
     }
-    const tileTemplateName = `${camelToKebabCase(parentTypeName)}-tile`;
-    addLiquidFile("partials", `${tileTemplateName}.public.liquid`, templateOfDocumentTile("doc"));
-    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="${tileTemplateName}">
-    {% for ${childrenVariableName} in ${childrenVariableName}.items %}
-      {% render "partials/${tileTemplateName}.public.liquid" doc: ${childrenVariableName} %}
-    {% endfor %}
-  </div>
+  {% out infiniteLoading(class: "Page List", paginatedDocs: ${childrenVariableName}, template: "partials/${cardTemplateName}") %}
 </div>`;
 }
 function templateOfFields(ctx, fields, { parentKey }) {
@@ -178,9 +174,9 @@ function templateOfField(ctx, fieldOrName, parentKey) {
   <div class="Field">
     {% for tag in ${parentKey}.${fieldName} %}
       {% if tag.inRightLanguage %}
-        <a href="{{ tag.url }}">{{ tag.title }}</a>
+        <a class="Label" href="{{ tag.url }}">{{ tag.title }}</a>
       {% else %}
-        <span>{{ tag.title }}</span>
+        <span class="Label">{{ tag.title }}</span>
       {% endif %}
     {% endfor %}
   </div>
@@ -201,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 }}"
@@ -216,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"
@@ -236,21 +232,23 @@ 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
         srcset="{{ largeIm.url }}"
         width="{{ largeIm.width }}"
         height="{{ largeIm.height }}"
-        media="(min-width: 361px)">
+        media="(min-width: 361px)"
+      >
       <img
         src="{{ smallIm.url }}"
         width="{{ smallIm.width }}"
         height="{{ smallIm.height }}"
         loading="lazy"
-        alt="">
+        alt=""
+      >
     </picture>
   </div>
 {% endif %}`;
@@ -273,7 +271,7 @@ function templateOfList(ctx, list, { listKey, nested }) {
         return `{% ${ifOrElsif} part.type == "${partType.typeName}" %}
   {% render "partials/${partTemplateName}.liquid" part: part %}`;
     })
-        .filter(Boolean);
+        .filter(isDef);
     partTemplates.push("{% endif %}");
     if (nested) {
         return `{% if ${listKey} %}
@@ -303,7 +301,7 @@ function templateOfPart(ctx, part, partKey) {
                 nested: true,
             })
             : undefined,
-    ].filter(Boolean);
+    ].filter(isDef);
     return `<section class="TextWidth">
   ${indent(templates.join("\n\n"), 1, { skipFirst: true })}
 </section>`;
@@ -318,34 +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 templateOfDocumentTile(docVariableName) {
-    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>
-    </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/jt-site-schema-helpers.js

@@ -53,3 +53,19 @@ export function getFirstSiteLanguage(siteSchema) {
         throw new Error("Missing language in site schema");
     return siteSchema.languages[0];
 }
+export function getPossibleJtLabelingFieldTypes(siteSchema, possibleTypes) {
+    const searchInTypes = possibleTypes ??
+        siteSchema.nodeTypes?.filter((type) => type.kind === "document" && type.documentKind === "regular") ??
+        [];
+    const result = [];
+    for (const documentType of searchInTypes) {
+        for (const fieldType of documentType.fields ?? []) {
+            if (typeof fieldType !== "string" &&
+                fieldType.storedAs === "labeling" &&
+                !result.find((alreadyThere) => alreadyThere.name === fieldType.name)) {
+                result.push(fieldType);
+            }
+        }
+    }
+    return result;
+}

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(".")}`;
+}