@paroicms/server/dist/rendering-payload/make-image-available.js

The ParoiCMS server

import { toAbsoluteUrl } from "@paroicms/internal-server-lib";
import { applyPixelRatioToResizeRule, generateImageSlug, rawToRenderedSize, } from "@paroicms/public-server-lib";
import { computeImageVariantSize } from "@paroicms/server-image-cache-engine";
import { toMSourceMedia } from "../common/medias/to-media-values.js";
import { makeUrlOfImageVariant, makeUrlOfMediaFile } from "../helpers/url-helpers.js";
export async function makeImageAvailableByHandle(renderingContext, imageSel, requested) {
    const { siteContext } = renderingContext;
    const media = await siteContext.mediaStorage.getMedia(imageSel);
    if (!media)
        return;
    if (media.kind !== "image") {
        throw new Error(`media '${media.id}' (${imageSel.handle}) should be an image`);
    }
    return await makeImageAvailable(renderingContext, toMSourceMedia(siteContext, media), requested);
}
export async function makeImageAvailableById(renderingContext, imageSel, requested) {
    const { siteContext } = renderingContext;
    const media = await siteContext.mediaStorage.getMedia(imageSel);
    if (!media)
        throw new Error(`missing image '${imageSel.mediaId}'`);
    if (media.kind !== "image")
        throw new Error(`media '${media.id}' should be an image`);
    return await makeImageAvailable(renderingContext, toMSourceMedia(siteContext, media), requested);
}
export async function makeImageAvailable(renderingContext, image, requested) {
    const { siteContext } = renderingContext;
    const pixelRatio = requested.pixelRatio ?? image.pixelRatio ?? siteContext.themeConf.pixelRatio;
    const rawResizeR = applyPixelRatioToResizeRule(requested.resizeRule, pixelRatio);
    if (image.mediaType === "image/svg+xml") {
        return handleSvgImageVariant(siteContext, image, rawResizeR, pixelRatio);
    }
    const [{ resourceVersion, mediaType, rawWidth, rawHeight, rawSizeName, slug }] = await renderingContext.imageCacheTransaction.makeImageAvailable([
        {
            sourceImage: {
                mediaId: image.mediaId,
                mediaType: image.mediaType,
                rawWidth: image.rawWidth,
                rawHeight: image.rawHeight,
                slug: generateImageSlug(image.originalName),
            },
            rawResizeR,
            mediaType: requested.mediaType,
        },
    ]);
    const url = makeUrlOfImageVariant(siteContext, {
        mediaId: image.mediaId,
        mediaType,
        rawSizeName,
        resourceVersion,
        slug,
    });
    return {
        kind: "image",
        isSource: false,
        mediaId: image.mediaId,
        mediaType,
        url: requested.absoluteUrl ? toAbsoluteUrl(siteContext, url) : url,
        rawWidth,
        rawHeight,
        pixelRatio,
        ...rawToRenderedSize({ rawWidth, rawHeight }, pixelRatio),
    };
}
export function handleSvgImageVariant(siteContext, image, rawResizeR, pixelRatio) {
    const sizeRegex = /^(\d+)x(\d+)$/;
    const sizeNameMatch = rawResizeR.match(sizeRegex);
    let nonCroppedRawResizeR;
    if (sizeNameMatch) {
        const [, w, h] = sizeNameMatch.map(Number);
        nonCroppedRawResizeR = w > h ? `${w}x` : `x${h}`;
    }
    const { rawWidth, rawHeight } = computeImageVariantSize({
        sourceImage: {
            rawWidth: image.rawWidth,
            rawHeight: image.rawHeight,
        },
        rawResizeR: nonCroppedRawResizeR ?? rawResizeR,
    });
    return {
        kind: "image",
        isSource: false,
        mediaType: "image/svg+xml",
        mediaId: image.mediaId,
        url: makeUrlOfMediaFile(siteContext, {
            mediaType: image.mediaType,
            mediaId: image.mediaId,
            originalName: image.originalName,
        }),
        rawWidth,
        rawHeight,
        pixelRatio,
        ...rawToRenderedSize({ rawWidth, rawHeight }, pixelRatio),
    };
}
//# sourceMappingURL=make-image-available.js.map