@paroicms/site-generator-plugin/backend/dist/generator/fake-content-generator/create-node-contents.js

ParoiCMS Site Generator Plugin

import { getRandomImagePath } from "../lib/images-lib.js";
export function createNodeContents(options) {
    const { ctx, nodeType, count, generatedContents, outputTags, language } = options;
    const result = [];
    for (let i = 0; i < count; ++i) {
        const generatedContent = generatedContents ? generatedContents[i] : {};
        if (generatedContent === undefined)
            break; // The LLM produced less than expected
        const nodeContent = createNodeContent({
            ctx,
            nodeType,
            language,
            generatedContent,
            outputTags,
        });
        result.push(nodeContent);
    }
    return result;
}
function createNodeContent(options) {
    const { ctx, nodeType, language, generatedContent, outputTags } = options;
    const fieldTypes = nodeType.fields ?? [];
    const medias = [];
    if (nodeType.kind === "document") {
        const { title, ...generatedFields } = generatedContent;
        const fields = toUpdateFieldValues(ctx, generatedFields, outputTags, fieldTypes, language);
        if (nodeType.withFeaturedImage) {
            medias.push({
                kind: "featuredImage",
                filePath: getRandomImagePath(),
            });
        }
        collectMediaFieldEntries(fieldTypes, medias);
        return { title, fields, medias: medias.length > 0 ? medias : undefined };
    }
    const fields = toUpdateFieldValues(ctx, generatedContent, outputTags, fieldTypes, language);
    collectMediaFieldEntries(fieldTypes, medias);
    return { fields, medias: medias.length > 0 ? medias : undefined };
}
function collectMediaFieldEntries(fieldTypes, medias) {
    for (const fieldType of fieldTypes) {
        if (fieldType.storedAs !== "mediaHandle")
            continue;
        if (fieldType.withGallery || fieldType.dataType === "gallery") {
            // Gallery field: generate 3-5 random images
            const count = 3 + Math.floor(Math.random() * 3);
            const filePaths = [];
            for (let i = 0; i < count; i++) {
                filePaths.push(getRandomImagePath());
            }
            medias.push({
                kind: "mediaGallery",
                fieldName: fieldType.name,
                filePaths,
            });
        }
        else {
            // Single media field
            medias.push({
                kind: "mediaField",
                fieldName: fieldType.name,
                filePath: getRandomImagePath(),
            });
        }
    }
}
function toUpdateFieldValues(ctx, content, outputTags, fieldTypes, language) {
    const result = {};
    for (const fieldType of fieldTypes) {
        const isMarkdown = outputTags.find((tag) => tag.key === fieldType.name)?.format === "markdown";
        const localized = fieldType.localized;
        const value = content[fieldType.name];
        const fieldValue = toUpdateFieldValue({
            ctx,
            fieldType,
            generatedValue: value,
            localized,
            language,
            isMarkdown,
        });
        if (fieldValue !== undefined) {
            result[fieldType.name] = fieldValue;
        }
    }
    return result;
}
function toUpdateFieldValue(options) {
    const { fieldType, generatedValue, localized, language, isMarkdown } = options;
    // Return the markdown string directly for markdown fields
    if (generatedValue !== undefined && localized) {
        if (fieldType.dataType === "string") {
            // For localized strings, return the value for the language
            return generatedValue[language];
        }
        if (fieldType.dataType === "json" && fieldType.renderAs === "html" && isMarkdown) {
            // Return the markdown string for the language
            return generatedValue[language];
        }
    }
    // Skip media fields - they are handled separately via setMedia
    if (fieldType.storedAs === "mediaHandle")
        return undefined;
    if (fieldType.dataType === "string") {
        const value = getDefaultStringValueForField(fieldType.name);
        if (value !== undefined) {
            return value;
        }
    }
    if (fieldType.storedAs === "labeling")
        return; // TODO: Generate values for labeling fields
}
function getDefaultStringValueForField(fieldName) {
    if (fieldName === "phone" || fieldName === "phone2")
        return "0123456789";
    if (fieldName === "phones")
        return JSON.stringify(["0123456789", "9876543210"]);
    if (fieldName === "updateDateTime")
        return new Date().toISOString();
    return;
}
export function generateLocalizedFooterMention(siteSchema) {
    const { languages } = siteSchema;
    return Object.fromEntries(languages.map((language) => [language, 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;
}