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

ParoiCMS Site Generator Plugin

import markdownToDelta from "markdown-to-quill-delta";
import { getRandomImagePath } from "../lib/images-lib.js";
export function createNodeContents(options) {
    const { 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({
            nodeType,
            language,
            generatedContent,
            outputTags,
        });
        result.push(nodeContent);
    }
    return result;
}
function createNodeContent(options) {
    const { nodeType, language, generatedContent, outputTags } = options;
    const fieldTypes = nodeType.fields ?? [];
    if (nodeType.kind === "document") {
        const { title, ...generatedFields } = generatedContent;
        const fields = toRiFieldSetContent(generatedFields, outputTags, fieldTypes, language);
        const featuredImage = nodeType.withFeaturedImage
            ? {
                file: getRandomImagePath(),
            }
            : undefined;
        return {
            title,
            featuredImage,
            fields,
        };
    }
    const fields = toRiFieldSetContent(generatedContent, outputTags, fieldTypes, language);
    return { fields };
}
function toRiFieldSetContent(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 fieldContent = toRiFieldContent({
            fieldType,
            generatedValue: value,
            localized,
            language,
            isMarkdown,
        });
        if (fieldContent !== undefined) {
            result[fieldType.name] = fieldContent;
        }
    }
    return result;
}
function toRiFieldContent(options) {
    const { fieldType, generatedValue, localized, language, isMarkdown } = options;
    if (generatedValue !== undefined && localized) {
        if (fieldType.dataType === "string") {
            return {
                dataType: "string",
                localized: true,
                value: generatedValue,
            };
        }
        if (fieldType.dataType === "json" && fieldType.renderAs === "html" && isMarkdown) {
            return toRiQuillDeltaContent(generatedValue);
        }
    }
    if (fieldType.storedAs === "mediaHandle") {
        if (fieldType.dataType === "media") {
            const file = getRandomImagePath();
            return localized
                ? {
                    dataType: "media",
                    localized: true,
                    value: { [language]: { file } },
                }
                : {
                    dataType: "media",
                    localized: false,
                    value: { file },
                };
        }
        if (fieldType.dataType === "gallery") {
            const files = [
                getRandomImagePath(),
                getRandomImagePath(),
                getRandomImagePath(),
                getRandomImagePath(),
                getRandomImagePath(),
                getRandomImagePath(),
            ];
            return localized
                ? {
                    dataType: "gallery",
                    localized: true,
                    value: { [language]: { files } },
                }
                : {
                    dataType: "gallery",
                    localized: false,
                    value: { files },
                };
        }
    }
    if (fieldType.dataType === "string") {
        const value = getDefaultStringValueForField(fieldType.name);
        if (value !== undefined) {
            return localized
                ? {
                    dataType: "string",
                    localized: true,
                    value: { [language]: value },
                }
                : {
                    dataType: "string",
                    localized: false,
                    value,
                };
        }
    }
    if (fieldType.storedAs === "labeling")
        return; // TODO: Generate values for labeling fields
}
function toRiQuillDeltaContent(content) {
    return {
        dataType: "json",
        localized: true,
        value: Object.fromEntries(Object.entries(content).map(([language, text]) => [
            language,
            {
                j: {
                    ops: markdownToDelta(text),
                },
            },
        ])),
    };
}
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 undefined;
}
export function generateLocalizedFooterMention(siteSchema) {
    const { languages, languageLabels } = siteSchema;
    return Object.fromEntries(languages.map((language) => [
        language,
        {
            j: {
                ops: markdownToDelta(`Powered by ParoiCMS in ${languageLabels[language]}`),
            },
        },
    ]));
}