@paroicms/server/dist/rendering-payload/field-values.js

The ParoiCMS server

import { getNodeTypeByName } from "@paroicms/internal-anywhere-lib";
import { encodeLNodeId, isJsonFieldValue, isMediaHandleValue, isReadLabelingFieldValue, pickATermTitle, } from "@paroicms/public-anywhere-lib";
import { loadFieldValues } from "../admin-backend/fields/load-fields.queries.js";
import { getHandleOfFieldOnNode } from "../common/media-handles.helpers.js";
import { toTpSourceMedia } from "../common/medias/to-media-values.js";
import { makeCacheDependencyKey } from "../common/text-cache.js";
import { createLiquidDrop } from "../liquidjs-tools/liquidjs-drop.js";
import { executeRenderingHook } from "../plugin-services/rendering-hook.js";
import { getUrlOfDocument } from "../rendered-site/page-route/make-url.js";
import { createDocPayloadDrop } from "./create-doc-drop.js";
import { getDocItem } from "./doc-values.queries.js";
export async function loadPublicFieldValues(renderingContext, options) {
    const { siteContext } = renderingContext;
    let fieldTypes = getNodeTypeByName(siteContext.siteSchema, options.typeName).fields ?? [];
    const { fieldNames } = options;
    if (fieldNames) {
        fieldTypes = fieldTypes.filter((f) => fieldNames.includes(f.name));
    }
    const rawValues = await loadFieldValues(siteContext, {
        fieldTypes,
        nodeId: options.lNodeId.nodeId,
        language: options.lNodeId.language,
        publishedOnly: true,
    });
    const values = await executeRenderingHook(renderingContext, "fieldPreprocessor", {
        fieldTypes,
        values: rawValues,
        options: {
            absoluteUrls: false,
        },
    });
    const map = new Map(fieldTypes.map((f) => [f.name, f]));
    const result = {};
    for (const [fieldName, value] of Object.entries(values)) {
        const fType = map.get(fieldName);
        if (!fType || !(fType.name in values))
            throw new Error(`missing field type for '${fieldName}'`);
        result[fieldName] = makeFieldValueOrLoader(renderingContext, fType, value, options.lNodeId.language);
        if (fType.withGallery) {
            result[`${fieldName}_gallery`] = createWithGalleryFieldLoader(renderingContext, fType, options.lNodeId.nodeId);
        }
    }
    return createLiquidDrop(renderingContext, {
        renderingCacheKey: `fields:${encodeLNodeId(options.lNodeId)}:${options.fieldNames?.join(",") ?? "full"}`,
        values: result,
    });
}
function createWithGalleryFieldLoader(renderingContext, fieldType, nodeId) {
    const { siteContext } = renderingContext;
    const handle = getHandleOfFieldOnNode(siteContext, {
        fieldType,
        nodeId,
    });
    return makeMediaFieldLoader(renderingContext, {
        dataType: "gallery",
    }, handle);
}
function makeFieldValueOrLoader(renderingContext, fType, val, language) {
    if (fType.storedAs === "mediaHandle") {
        if (!isMediaHandleValue(val))
            throw new Error(`invalid media handle value for "${fType.name}"`);
        return makeMediaFieldLoader(renderingContext, fType, val.h);
    }
    if (val === undefined)
        return;
    if (fType.storedAs === "labeling") {
        if (!isReadLabelingFieldValue(val)) {
            throw new Error(`invalid labeling field value for "${fType.name}"`);
        }
        return val.t.map((t) => createTpTerm(renderingContext, t, language));
    }
    if (isJsonFieldValue(val))
        return val.j;
    return val;
}
function createTpTerm(renderingContext, term, rightLanguage) {
    const { siteContext } = renderingContext;
    const { language, title } = pickATermTitle(term, rightLanguage);
    const termId = { language, nodeId: term.nodeId };
    const inRightLanguage = rightLanguage === language;
    renderingContext.addDependencyKey(makeCacheDependencyKey({ documentId: termId }));
    return createLiquidDrop(renderingContext, {
        renderingCacheKey: `term:${encodeLNodeId(termId)}`,
        values: {
            nodeId: term.nodeId,
            title,
            inRightLanguage,
            language,
            languageLabel: siteContext.siteSchema.languageLabels[language],
            url: inRightLanguage
                ? async () => await getUrlOfDocument(siteContext, renderingContext.tracker, {
                    nodeId: term.nodeId,
                    language,
                })
                : undefined,
            doc: async () => createDocPayloadDrop(renderingContext, await getDocItem(siteContext, renderingContext.tracker, termId)),
        },
    });
}
function makeMediaFieldLoader(renderingContext, fType, handle) {
    const { siteContext, withAttachedData } = renderingContext;
    return async () => {
        if (fType.dataType === "media") {
            const media = await siteContext.mediaStorage.getMedia({ handle, withAttachedData });
            return media ? toTpSourceMedia(renderingContext, media) : undefined;
        }
        const medias = await siteContext.mediaStorage.getMedias({ handle, withAttachedData });
        const renderedMedias = medias.map((m) => toTpSourceMedia(renderingContext, m, { galleryHandle: handle }));
        renderingContext.sourceImagesByGalleryHandles.set(handle, renderedMedias.filter((m) => m.kind === "image"));
        return medias.length === 0 ? undefined : renderedMedias;
    };
}
//# sourceMappingURL=field-values.js.map