@paroicms/site-generator-plugin 0.11.0 → 0.13.0

package/gen-backend/dist/generator/fake-content-generator/content-report.js

@@ -0,0 +1,81 @@
+export function createGeneratedContentReport() {
+    let totalEntryCount = 0;
+    const llmReports = [];
+    const internalIds = {};
+    const childNodeIds = new Map();
+    return {
+        getResults() {
+            return {
+                entryCount: totalEntryCount,
+                llmReports,
+                idPicker: createIdPicker(internalIds, childNodeIds),
+            };
+        },
+        add(entryCount, llmReport) {
+            totalEntryCount += entryCount;
+            if (llmReport) {
+                llmReports.push(llmReport);
+            }
+        },
+        addId({ typeName, id: idOrIds, parentNodeId }) {
+            for (const { language, nodeId } of Array.isArray(idOrIds) ? idOrIds : [idOrIds]) {
+                let languageDict = internalIds[language];
+                if (!languageDict) {
+                    languageDict = {};
+                    internalIds[language] = languageDict;
+                }
+                let nodeIds = languageDict[typeName];
+                if (!nodeIds) {
+                    nodeIds = new Set();
+                    languageDict[typeName] = nodeIds;
+                }
+                nodeIds.add(nodeId);
+                if (parentNodeId !== undefined) {
+                    let childIds = childNodeIds.get(parentNodeId);
+                    if (!childIds) {
+                        childIds = new Set();
+                        childNodeIds.set(parentNodeId, childIds);
+                    }
+                    childIds.add(nodeId);
+                }
+            }
+        },
+    };
+}
+function createIdPicker(ids, childNodeIds) {
+    const getNodeIdsByLanguageAndType = (language, typeName) => {
+        const languageDict = ids[language];
+        if (!languageDict)
+            return [];
+        const nodeIds = languageDict[typeName];
+        if (!nodeIds)
+            return [];
+        return Array.from(nodeIds);
+    };
+    const getNodeIdsByType = (typeName) => {
+        const nodeIds = new Set();
+        for (const language of Object.keys(ids)) {
+            const found = getNodeIdsByLanguageAndType(language, typeName);
+            found.forEach((id) => nodeIds.add(id));
+        }
+        return Array.from(nodeIds);
+    };
+    const getNodeIdsByParent = (parentNodeId) => {
+        const nodeIds = childNodeIds.get(parentNodeId);
+        if (!nodeIds)
+            return [];
+        return Array.from(nodeIds);
+    };
+    const picker = {
+        pickNodeIds(selector, count) {
+            const nodeIds = "typeName" in selector
+                ? getNodeIdsByType(selector.typeName)
+                : getNodeIdsByParent(selector.parentNodeId);
+            if (count === undefined || nodeIds.length <= count)
+                return nodeIds;
+            const shuffled = [...nodeIds].sort(() => Math.random() - 0.5);
+            return shuffled.slice(0, count);
+        },
+    };
+    return picker;
+}

package/gen-backend/dist/generator/fake-content-generator/create-database-with-fake-content.js

@@ -0,0 +1,80 @@
+import { getPartTypeByName, getRegularDocumentTypeByName, getRoutingDocumentTypeByName, } from "@paroicms/internal-anywhere-lib";
+import { createSimpleTranslator, } from "@paroicms/public-server-lib";
+import { updateGeneratedSiteStepSetAsCompleted, } from "../../db/db-write.queries.js";
+import { createTaskCollector } from "../lib/tasks.js";
+import { createGeneratedContentReport } from "./content-report.js";
+import { addParts, addRegularDocuments, updateRoutingDocument } from "./fill-nodels.js";
+import { updateSiteFields } from "./fill-site-fields.js";
+import { updateNodelsWithTaxonomies } from "./fill-taxonomy-fields.js";
+export async function fillSiteWithFakeContent(ctx, stepHandle, { regSite, localizedValues }) {
+    const { service } = ctx;
+    const { fqdn } = regSite;
+    const report = createGeneratedContentReport();
+    const { siteSchema, siteIds } = await service.connector.loadSiteSchemaAndIds(fqdn);
+    const schemaI18n = createSimpleTranslator({
+        labels: siteSchema.l10n,
+        logger: ctx.logger,
+    });
+    await updateSiteFields(ctx, report, { fqdn, siteSchema, siteTitle: localizedValues.siteTitle });
+    const tasks = createTaskCollector(ctx);
+    fillRoutingDocumentAndAddChildren(ctx, tasks, report, {
+        fqdn,
+        siteSchema,
+        schemaI18n,
+    }, {
+        routingIds: siteIds.homeIds,
+        nodeType: siteSchema.nodeTypes.home,
+    });
+    const { promise } = tasks.runAll({ maxParallel: 10, rateLimitPerSecond: 3 });
+    const { doneCount, errorMessages } = await promise;
+    const results = report.getResults();
+    await updateNodelsWithTaxonomies(ctx, {
+        siteSchema,
+        idPicker: results.idPicker,
+        fqdn,
+    });
+    if (errorMessages.length > 0) {
+        ctx.logger.warn(`Failed to generate documents:\n  - ${errorMessages.join("\n  - ")}`);
+    }
+    ctx.logger.debug(`… Executed ${doneCount} generating tasks`);
+    await updateGeneratedSiteStepSetAsCompleted(ctx, stepHandle, {
+        status: "completed",
+        contentEntryCount: results.entryCount,
+        contentInputTokenCount: results.llmReports.reduce((acc, r) => acc + r.inputTokenCount, 0),
+        contentOutputTokenCount: results.llmReports.reduce((acc, r) => acc + (r.outputTokenCount ?? 0), 0),
+        contentErrors: errorMessages.length > 0 ? errorMessages.join("\n  - ") : null,
+    });
+}
+function fillRoutingDocumentAndAddChildren(ctx, tasks, report, siteOptions, nodeOptions) {
+    const { routingIds, nodeType } = nodeOptions;
+    const { siteSchema } = siteOptions;
+    tasks.add(() => updateRoutingDocument(ctx, report, siteOptions, nodeOptions));
+    for (const listType of nodeType.lists ?? []) {
+        for (const typeName of listType.parts) {
+            const partType = getPartTypeByName(siteSchema, typeName);
+            tasks.add(() => addParts(ctx, report, siteOptions, {
+                parentNodeId: routingIds.nodeId,
+                nodeType: partType,
+                documentType: nodeType,
+            }));
+        }
+    }
+    for (const typeName of nodeType.routingChildren ?? []) {
+        const childType = getRoutingDocumentTypeByName(siteSchema, typeName);
+        const childIds = routingIds.children?.[typeName];
+        if (!childIds)
+            throw new Error(`Missing childIds for ${typeName}`);
+        fillRoutingDocumentAndAddChildren(ctx, tasks, report, siteOptions, {
+            routingIds: childIds,
+            nodeType: childType,
+        });
+    }
+    for (const typeName of nodeType.regularChildren ?? []) {
+        const childType = getRegularDocumentTypeByName(siteSchema, typeName);
+        tasks.add(() => addRegularDocuments(ctx, report, siteOptions, {
+            parentNodeId: routingIds.nodeId,
+            nodeType: childType,
+            documentType: childType,
+        }));
+    }
+}

package/gen-backend/dist/generator/fake-content-generator/fill-nodels.js

@@ -0,0 +1,115 @@
+import { dedupMessages } from "./content-helpers.js";
+import { generateFieldSetContent, generateMultipleFieldSetContents, } from "./generate-fake-content.js";
+export async function updateRoutingDocument(ctx, report, siteOptions, nodeOptions) {
+    ctx.logger.debug(`[TASK] Updating routing document "${nodeOptions.nodeType.typeName}"…`);
+    const { routingIds, nodeType } = nodeOptions;
+    const { fqdn, siteSchema, schemaI18n } = siteOptions;
+    const content = await generateFieldSetContent(ctx, {
+        nodeType,
+        documentType: nodeType,
+        siteSchema,
+        schemaI18n,
+        withTitle: false,
+        llmTaskName: nodeType.kebabName,
+    }, report);
+    await ctx.service.connector.updateNodeContent(fqdn, {
+        nodeId: routingIds.nodeId,
+        content: toRiDocumentContent(content, nodeType),
+    });
+    for (const language of siteSchema.languages) {
+        report.addId({
+            typeName: nodeType.typeName,
+            id: {
+                nodeId: routingIds.nodeId,
+                language,
+            },
+            parentNodeId: undefined,
+        });
+    }
+}
+export async function addRegularDocuments(ctx, report, siteOptions, nodeOptions) {
+    ctx.logger.debug(`[TASK] Adding regular documents "${nodeOptions.nodeType.typeName}"…`);
+    const { parentNodeId, nodeType, documentType } = nodeOptions;
+    const { fqdn, siteSchema, schemaI18n } = siteOptions;
+    const tolerateErrors = {
+        errorMessages: [],
+    };
+    const list = await generateMultipleFieldSetContents(ctx, {
+        siteSchema,
+        nodeType,
+        documentType,
+        schemaI18n,
+        count: getDefaultNodeContentCount(nodeType),
+        withTitle: true,
+        tolerateErrors,
+        llmTaskName: nodeType.kebabName,
+    }, report);
+    const errorMessages = dedupMessages(tolerateErrors.errorMessages);
+    if (errorMessages.length > 0) {
+        ctx.logger.warn(`Error generating content for ${nodeType.typeName}:\n  - ${errorMessages.join("\n  - ")}`);
+    }
+    const insertedIds = await ctx.service.connector.addMultipleDocumentContents(fqdn, {
+        parentNodeId,
+        contents: list.map((content) => toRiDocumentContent(content, nodeType)),
+    });
+    report.addId({ typeName: nodeType.typeName, id: insertedIds, parentNodeId });
+}
+export async function addParts(ctx, report, siteOptions, nodeOptions) {
+    ctx.logger.debug(`[TASK] Adding parts "${nodeOptions.nodeType.typeName}"…`);
+    const { parentNodeId, nodeType, documentType } = nodeOptions;
+    const { fqdn, siteSchema, schemaI18n } = siteOptions;
+    const tolerateErrors = {
+        errorMessages: [],
+    };
+    const list = await generateMultipleFieldSetContents(ctx, {
+        siteSchema,
+        nodeType,
+        documentType,
+        schemaI18n,
+        count: getDefaultNodeContentCount(nodeType),
+        withTitle: true,
+        tolerateErrors,
+        llmTaskName: nodeType.kebabName,
+    }, report);
+    const errorMessages = dedupMessages(tolerateErrors.errorMessages);
+    if (errorMessages.length > 0) {
+        ctx.logger.warn(`Error generating content for ${nodeType.typeName}:\n  - ${errorMessages.join("\n  - ")}`);
+    }
+    const insertedIds = await ctx.service.connector.addMultiplePartContents(fqdn, {
+        parentNodeId,
+        contents: list.map((content) => toRiPartContent(content, nodeType)),
+    });
+    report.addId({ typeName: nodeType.typeName, id: insertedIds, parentNodeId });
+}
+function toRiDocumentContent(content, nodeType) {
+    const { title, fields, featuredImage } = content;
+    return {
+        kind: "document",
+        typeName: nodeType.typeName,
+        title,
+        featuredImage,
+        fields,
+    };
+}
+function toRiPartContent(content, nodeType) {
+    const { fields } = content;
+    return {
+        kind: "part",
+        typeName: nodeType.typeName,
+        fields,
+    };
+}
+function getDefaultNodeContentCount(nodeType) {
+    if (nodeType.kind === "site")
+        throw new Error("Cannot generate content for site node type");
+    if (nodeType.kind === "document") {
+        if (nodeType.documentKind === "routing")
+            return 1;
+        if (nodeType.route === ":yyyy/:mm/:dd/:relativeId-:slug")
+            return 14; // 4
+        return 8; // 2
+    }
+    if (nodeType.kind === "part")
+        return 8; // 2
+    throw new Error(`Unknown node type kind: ${nodeType.kind}`);
+}

package/gen-backend/dist/generator/fake-content-generator/fill-site-fields.js

@@ -0,0 +1,63 @@
+import { getRandomImagePath } from "../lib/images-lib.js";
+import { generateLocalizedFooterMention } from "./create-node-contents.js";
+export async function updateSiteFields(ctx, _report, options) {
+    const { service, logger } = ctx;
+    logger.debug("Updating site fields…");
+    const { fqdn, siteSchema, siteTitle } = options;
+    const siteType = siteSchema.nodeTypes._site;
+    const logoImageFile = getRandomImagePath();
+    const fields = [
+        [
+            "title",
+            {
+                dataType: "string",
+                localized: true,
+                value: siteTitle,
+            },
+        ],
+        [
+            "favicon",
+            {
+                dataType: "media",
+                localized: false,
+                value: {
+                    file: logoImageFile,
+                },
+            },
+        ],
+        [
+            "ogImage",
+            {
+                dataType: "media",
+                localized: false,
+                value: {
+                    file: logoImageFile,
+                },
+            },
+        ],
+    ];
+    if (siteType.fields.some((f) => f.name === "logo")) {
+        fields.push([
+            "logo",
+            {
+                dataType: "media",
+                localized: false,
+                value: {
+                    file: logoImageFile,
+                },
+            },
+        ]);
+    }
+    if (siteType.fields.some((f) => f.name === "footerMention")) {
+        fields.push([
+            "footerMention",
+            {
+                dataType: "json",
+                localized: true,
+                value: generateLocalizedFooterMention(siteSchema),
+            },
+        ]);
+    }
+    await service.connector.updateSiteFields(fqdn, Object.fromEntries(fields));
+    logger.debug("… Site fields updated");
+}

package/gen-backend/dist/generator/fake-content-generator/fill-taxonomy-fields.js

@@ -0,0 +1,57 @@
+export async function updateNodelsWithTaxonomies(ctx, options) {
+    const { service } = ctx;
+    const { siteSchema, idPicker, fqdn } = options;
+    const { nodeTypes } = siteSchema;
+    for (const nodeType of Object.values(nodeTypes)) {
+        const labelingFields = nodeType.fields?.filter((f) => f.dataType === "labeling");
+        if (!labelingFields || labelingFields.length === 0)
+            continue;
+        await updateLabelingFields(ctx, {
+            idPicker,
+            fqdn,
+            nodeType,
+            labelingFields,
+        }, service);
+    }
+}
+async function updateLabelingFields(ctx, options, service) {
+    const { fqdn, nodeType, labelingFields, idPicker } = options;
+    if (nodeType.kind !== "document" && nodeType.kind !== "part")
+        return;
+    const nodeIds = idPicker.pickNodeIds({ typeName: nodeType.typeName });
+    for (const nodeId of nodeIds) {
+        const fieldValues = [];
+        for (const field of labelingFields) {
+            const taxonomyIds = idPicker.pickNodeIds({ typeName: field.taxonomy });
+            if (taxonomyIds.length !== 1) {
+                if (taxonomyIds.length > 1) {
+                    ctx.logger.warn(`Expected one taxonomy ID for "${field.taxonomy}", got ${taxonomyIds.length}`);
+                }
+                continue;
+            }
+            const taxonomyNodeId = taxonomyIds[0];
+            const max = field.multiple ? Math.floor(Math.random() * 2) + 1 : 1;
+            const termNodeIds = idPicker.pickNodeIds({ parentNodeId: taxonomyNodeId }, max);
+            if (termNodeIds.length === 0)
+                continue;
+            fieldValues.push([
+                field.name,
+                {
+                    dataType: "labeling",
+                    localized: false,
+                    value: { t: termNodeIds },
+                },
+            ]);
+        }
+        if (fieldValues.length === 0)
+            continue;
+        await service.connector.updateNodeContent(fqdn, {
+            nodeId,
+            content: {
+                kind: nodeType.kind,
+                typeName: nodeType.typeName,
+                fields: Object.fromEntries(fieldValues),
+            },
+        });
+    }
+}

package/gen-backend/dist/generator/lib/create-prompt.js

@@ -7,8 +7,8 @@ const contextContent = await readPromptFile("0-context.md");
 const siteSchemaTsDefs = await readFile(join(connectorPackageDir, "typeonly", "site-schema-json-types.d.ts"), "utf-8");
 const predefinedFields = JSON.parse(await readPromptFile("predefined-fields.json"));
 export async function createPromptTemplate(options) {
-    const { fileName, withSiteSchemaTsDefs } = options;
-    const promptContent = await readPromptFile(fileName);
+    const { filename, withSiteSchemaTsDefs } = options;
+    const promptContent = await readPromptFile(filename);
     const schemaTypeDefTemplate = withSiteSchemaTsDefs
         ? `
 
@@ -29,8 +29,8 @@ ${promptContent}
 `;
     return buildPromptTemplate(template);
 }
-export async function readPromptFile(fileName) {
-    return await readFile(join(projectDir, "prompts", fileName), "utf-8");
+export async function readPromptFile(filename) {
+    return await readFile(join(projectDir, "prompts", filename), "utf-8");
 }
 export function getPredefinedFields() {
     if (!predefinedFields)

package/gen-backend/dist/generator/llm-queries/invoke-message-guard.js

@@ -5,7 +5,7 @@ import { createPromptTemplate } from "../lib/create-prompt.js";
 import { debugLlmOutput } from "../lib/debug-utils.js";
 import { parseLlmResponseAsProperties } from "../lib/parse-llm-response.js";
 const guardPrompt = await createPromptTemplate({
-    fileName: "message-guard.md",
+    filename: "message-guard.md",
 });
 const invalidCauses = new Set(["rude", "malicious", "outOfScope", "technicalLimits", "noSense"]);
 export async function invokeMessageGuard(ctx, input, { skipOutOfScopeCheck = false } = {}) {

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

@@ -11,11 +11,11 @@ import { createL10n } from "../site-schema-generator/create-l10n.js";
 import { createSiteSchemaFromAnalysis } from "../site-schema-generator/create-site-schema.js";
 import { invokeUpdateSiteSchema } from "./invoke-update-site-schema.js";
 export const analyzePrompt = await createPromptTemplate({
-    fileName: "initial-1-analysis.md",
+    filename: "initial-1-analysis.md",
     withSiteSchemaTsDefs: true,
 });
 const fieldsPrompt = await createPromptTemplate({
-    fileName: "initial-2-fields.md",
+    filename: "initial-2-fields.md",
     withSiteSchemaTsDefs: true,
 });
 export async function startInitialAnalysis(ctx, input) {

package/gen-backend/dist/generator/llm-queries/invoke-update-site-schema.js

@@ -6,10 +6,10 @@ import { debugLlmOutput } from "../lib/debug-utils.js";
 import { parseLlmResponseAsProperties } from "../lib/parse-llm-response.js";
 import { safeCallStep } from "../lib/session-utils.js";
 const prompt1Tpl = await createPromptTemplate({
-    fileName: "update-site-schema-1-write-details.md",
+    filename: "update-site-schema-1-write-details.md",
 });
 const prompt2Tpl = await createPromptTemplate({
-    fileName: "update-site-schema-2-execute.md",
+    filename: "update-site-schema-2-execute.md",
 });
 export async function startUpdateSiteSchema(ctx, input) {
     const fromStepSchema = await readStepSchema(ctx, input.fromStepNumber);

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

@@ -37,7 +37,7 @@ function templateOfSiteLogoTitle(ctx) {
     const content = [
         siteType.fields?.includes("logo")
             ? `{% if site.field.logo %}
-  {% useImage logo uid: site.field.logo.uid size: "50x50" %}
+  {% useImage logo image: site.field.logo resize: "50x50" %}
   <img
     src="{{ logo.url }}"
     width="{{ logo.width }}"

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

@@ -197,7 +197,7 @@ function templateOfField(ctx, fieldOrName, parentKey) {
     if (dataType === "gallery") {
         return `<div class="Field">
   {% for media in ${parentKey}.${fieldName} %}
-    {% useImage im uid: media.uid size: "150x150" %}
+    {% useImage im image: media resize: "150x150" %}
     <img
       class="Field-img"
       src="{{ im.url }}"
@@ -205,13 +205,14 @@ function templateOfField(ctx, fieldOrName, parentKey) {
       height="{{ im.height }}"
       loading="lazy"
       alt=""
-      data-zoom-src="{{ media.uid | imageZoomUrl }}">
+      {{ media | zoomable }}
+    >
   {% endfor %}
 </div>`;
     }
     if (dataType === "media") {
-        const mediaUidKey = `${parentKey}.${fieldName}.uid`;
-        return `{% useImage im uid:${mediaUidKey} size: "x250x" %}
+        const mediaKey = `${parentKey}.${fieldName}`;
+        return `{% useImage im image: ${mediaKey} resize: "x250x" %}
 <div class="Field">
   <img
     class="Field-img"
@@ -220,7 +221,8 @@ function templateOfField(ctx, fieldOrName, parentKey) {
     height="{{ im.height }}"
     loading="lazy"
     alt=""
-    data-zoom-src="{{ ${mediaUidKey} | imageZoomUrl }}">>
+    {{ ${mediaKey} | zoomable }}
+  >
 </div>`;
     }
     if (fieldName === "title") {
@@ -230,15 +232,15 @@ function templateOfField(ctx, fieldOrName, parentKey) {
 }
 function templateOfPicture({ imageKey }) {
     return `{% if ${imageKey} %}
-  {% useImage smallIm uid: ${imageKey}.uid size: "360x48" %}
-  {% useImage largeIm uid: ${imageKey}.uid size: "1200x160" %}
+  {% useImage smallIm image: ${imageKey} resize: "360x48" %}
+  {% useImage largeIm image: ${imageKey} resize: "1200x160" %}
   <div class="Container">
     <picture class="Hero">
       <source
         srcset="{{ largeIm.url }}"
         width="{{ largeIm.width }}"
         height="{{ largeIm.height }}"
-        media="(min-width: 360px)">
+        media="(min-width: 361px)">
       <img
         src="{{ smallIm.url }}"
         width="{{ smallIm.width }}"
@@ -327,7 +329,7 @@ function templateOfDocumentTile(docVariableName) {
   <article>
     {% if ${docVariableName}.defaultImage %}
       <div>
-        {% useImage im uid: ${docVariableName}.defaultImage.uid size: "120x120" %}
+        {% useImage im image: ${docVariableName}.defaultImage resize: "120x120" %}
         <img
           src="{{ im.url }}"
           width="{{ im.width }}"

package/gen-backend/dist/generator/site-generator/site-generator.js

@@ -4,7 +4,7 @@ import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { loadStep, readStepSchema } from "../../db/db-read.queries.js";
 import { insertStep, saveGeneratedSiteStep, } from "../../db/db-write.queries.js";
-import { fillSiteWithFakeContent } from "../fake-content-generator.ts/create-database-with-fake-content.js";
+import { fillSiteWithFakeContent } from "../fake-content-generator/create-database-with-fake-content.js";
 import { safeCallStep } from "../lib/session-utils.js";
 import { createTheme } from "./theme-creator.js";
 export async function generateSite(ctx, input) {
@@ -78,8 +78,10 @@ function getPackageJsonContent(options) {
         dependencies: {
             "@paroicms/contact-form-plugin": "*",
             "@paroicms/content-loading-plugin": "*",
+            "@paroicms/internal-link-plugin": "*",
             "@paroicms/public-menu-plugin": "*",
             "@paroicms/quill-editor-plugin": "*",
+            "@paroicms/video-plugin": "*",
             "@paroicms/server": "*",
         },
         devDependencies: {

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

@@ -59,12 +59,12 @@ function createThemeCreatorContext(siteSchema) {
                 f[language] = value;
             }
         },
-        hasLiquidFile(directory, fileName) {
-            const path = directory === "root" ? `templates/${fileName}` : `templates/${directory}/${fileName}`;
+        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}`;
+        addLiquidFile(directory, filename, content, { skipIfExists = false } = {}) {
+            const path = directory === "root" ? `templates/${filename}` : `templates/${directory}/${filename}`;
             if (liquidFiles.has(path)) {
                 if (skipIfExists)
                     return;

package/gen-backend/dist/generator/site-generator/theme-css.js

@@ -216,27 +216,35 @@ nav a.active::after {
   display: block;
 }
 
-.Text .Img {
-  height: auto;
+.Text .Fig {
+  display: table;
+  margin: 0;
 }
-
-.Text .Img.left {
+.Text .Fig.left {
   float: left;
   margin: 5px 20px 10px 0;
 }
-
-.Text .Img.right {
+.Text .Fig.right {
   float: right;
   margin: 5px 0 10px 20px;
 }
-
-.Text .Img.left, .Text .Img.right {
-  max-width: 50%;
+.Text .Fig.center {
+  clear: both;
+  margin: 20px auto;
 }
-
-.Text .Img.center {
+.Text .Fig-media {
   display: block;
-  margin: 20px auto;
+  height: auto;
+  max-height: 100%;
+  max-width: 100%;
+}
+.Text .Fig-caption {
+  caption-side: bottom;
+  color: #666;
+  display: table-caption;
+  font-size: 0.875rem;
+  margin-top: 8px;
+  text-align: center;
 }
 
 .Text a,

package/gen-backend/dist/generator/site-schema-generator/create-site-schema.js

@@ -5,10 +5,11 @@ export function createSiteSchemaFromAnalysis(analysis) {
         version: "8",
         languages: [siteProperties.language],
         plugins: [
-            "@paroicms/quill-editor-plugin",
+            "@paroicms/contact-form-plugin",
             "@paroicms/content-loading-plugin",
+            "@paroicms/internal-link-plugin",
             "@paroicms/public-menu-plugin",
-            "@paroicms/contact-form-plugin",
+            "@paroicms/quill-editor-plugin",
             "@paroicms/video-plugin",
         ],
         nodeTypes: [
@@ -227,6 +228,11 @@ function toRoutingDocumentNodeType(typeName, saType) {
         ogType: saType.ogType,
         route: generateSlug(saType.label),
         withFeaturedImage: typeName !== "home" && !!saType.entryPage,
+        backOffice: saType.taxonomy
+            ? {
+                menuPlacement: "popup",
+            }
+            : undefined,
     };
 }
 function toRegularDocumentNodeType(typeName, saType) {

package/gen-backend/prompts/initial-1-analysis.md

@@ -126,6 +126,7 @@ Guidelines for creating the dictionnary YAML:
   - confidence: Your confidence level for the accuracy of this node type (0.0-1.0).
   - kind: Can be `routingDocument`, `regularDocument`, `part`.
   - entryPage: A Boolean indicating whether this is one of the very few first pages the visitor lands on (optional, routing document only).
+  - taxonomy: A boolean to indicate if this is a taxonomy (optional, routing document only).
   - temporal: A boolean to indicate if there is a temporal nature for this type of node (optional, regular document only).
   - ogType: (optional, and document only) If you think of a particular Open-Graph type for this document, give it here.
   - label: A label of the node type, in the _website language_.
@@ -199,12 +200,13 @@ post:
 tags:
   confidence: 0.9
   kind: routingDocument
+  taxonomy: true
   label: Tags
   description: Tags taxonomy for post documents.
 tag:
   confidence: 0.9
   kind: regularDocument
-  temporal: true
+  temporal: false
   label: Tag
   description: A tag is a term in the tags taxonomy.
 </correct_example>