@paroicms/server/dist/common/medias/media-lib.js

The ParoiCMS server

import { applyPixelRatioToResizeRule, generateImageSlug } from "@paroicms/public-server-lib";
import { computeImageVariantSize, createDefaultAdminFavicon, } from "@paroicms/server-image-cache-engine";
import { adminUiOwnerHandle } from "../../context.js";
import { makeUrlOfMediaFile } from "../../helpers/url-helpers.js";
import { getHandleOfSiteAdminFavicon } from "../media-handles.helpers.js";
import { toMImageVariant, toMSourceMedia } from "./to-media-values.js";
const thumbRawResizeR = "x200x";
export async function makeGqlMedias(siteContext, medias) {
    const gqlMedias = [];
    for (const media of medias) {
        const gqlMedia = await makeGqlMedia(siteContext, media);
        gqlMedias.push(gqlMedia);
    }
    return gqlMedias;
}
export async function makeGqlMedia(siteContext, media) {
    const source = toMSourceMedia(siteContext, media, { absoluteUrl: true });
    if (source.kind === "file") {
        return {
            source: JSON.stringify(source),
        };
    }
    return {
        source: JSON.stringify(source),
        thumb: JSON.stringify(await makeDefaultThumbAvailableForAdminUi(siteContext, source, {
            absoluteUrl: true,
        })),
    };
}
export async function makeDefaultThumbAvailableForAdminUi(siteContext, media, options) {
    return await registerImageVariant(siteContext, {
        autoCrop: false,
        sourceImage: {
            mediaId: media.mediaId,
            mediaType: media.mediaType,
            rawWidth: media.rawWidth,
            rawHeight: media.rawHeight,
            slug: generateImageSlug(media.originalName),
        },
        resizeRule: thumbRawResizeR,
        pixelRatio: 1,
        absoluteUrl: options.absoluteUrl,
        versionedUrl: true,
        ownerHandle: adminUiOwnerHandle,
        isHandleReusable: true,
        canBeRetrievedByOwner: false,
        originalName: media.originalName,
    });
}
export async function makeFaviconThumbReady(siteContext, handle) {
    const media = await siteContext.mediaStorage.getMedia({ handle });
    if (!media || media.kind !== "image")
        return;
    return await registerImageVariant(siteContext, {
        autoCrop: false,
        sourceImage: {
            mediaId: media.id,
            mediaType: media.mediaType,
            rawWidth: media.rawWidth,
            rawHeight: media.rawHeight,
            slug: generateImageSlug(media.originalName),
        },
        resizeRule: "128x128",
        pixelRatio: 1,
        absoluteUrl: true,
        versionedUrl: true,
        ownerHandle: adminUiOwnerHandle,
        isHandleReusable: true,
        canBeRetrievedByOwner: false,
        originalName: media.originalName,
    });
}
export async function createAdminFaviconFrom(siteContext, binaryFile) {
    const result = await createDefaultAdminFavicon(binaryFile);
    await siteContext.mediaStorage.addMedia({
        binaryFile: result.binaryFile,
        mediaType: result.mediaType,
        weightB: result.weightB,
        handle: getHandleOfSiteAdminFavicon(),
        originalName: "admin-favicon",
        image: {
            rawWidth: result.rawWidth,
            rawHeight: result.rawHeight,
            lossless: result.lossless,
        },
        replace: true,
        nodeId: siteContext.homeRoutingCluster.siteNodeId,
    });
}
export async function registerImageVariant(siteContext, { sourceImage, resizeRule, mediaType, pixelRatio, autoCrop = false, absoluteUrl, versionedUrl, ownerHandle, isHandleReusable, canBeRetrievedByOwner, originalName, }) {
    if (sourceImage.mediaType === "image/svg+xml") {
        return toSvgRegisteredImageVariant(siteContext, sourceImage, resizeRule, originalName, absoluteUrl);
    }
    const rawResizeR = applyPixelRatioToResizeRule(resizeRule, pixelRatio);
    const variant = await siteContext.imageCache.makeImageAvailable({
        sourceImage,
        mediaType,
        rawResizeR,
        autoCrop,
        ownerHandle,
        isHandleReusable,
        canBeRetrievedByOwner,
    });
    return toMImageVariant(siteContext, variant, {
        pixelRatio,
        absoluteUrl,
        unversionedUrl: versionedUrl ? undefined : { resizeRule },
    });
}
function toSvgRegisteredImageVariant(siteContext, sourceImage, resizeRule, originalName, absoluteUrl) {
    const { rawWidth, rawHeight } = computeImageVariantSize({ sourceImage, rawResizeR: resizeRule });
    return {
        kind: "image",
        isSource: false,
        mediaId: sourceImage.mediaId,
        url: makeUrlOfMediaFile(siteContext, {
            absoluteUrl,
            mediaType: sourceImage.mediaType,
            mediaId: sourceImage.mediaId,
            originalName,
        }),
        rawWidth,
        rawHeight,
        pixelRatio: 1,
        width: rawWidth,
        height: rawHeight,
        mediaType: "image/svg+xml",
    };
}
export async function makeGqlImageVariant(siteContext, media, options) {
    const { resizeRule, pixelRatio, ownerHandle, isHandleReusable, canBeRetrievedByOwner, mediaType, versionedUrl, } = options;
    const source = toMSourceMedia(siteContext, media, { absoluteUrl: true });
    if (source.kind !== "image") {
        throw new Error(`Cannot make image variant for ${source.kind} media "${source.mediaId}"`);
    }
    const variant = await registerImageVariant(siteContext, {
        autoCrop: false,
        sourceImage: {
            mediaId: source.mediaId,
            mediaType: source.mediaType,
            rawWidth: source.rawWidth,
            rawHeight: source.rawHeight,
            slug: generateImageSlug(media.originalName),
        },
        resizeRule,
        pixelRatio,
        absoluteUrl: true,
        versionedUrl,
        ownerHandle,
        isHandleReusable,
        canBeRetrievedByOwner,
        originalName: media.originalName,
        mediaType,
    });
    return {
        source: JSON.stringify(source),
        variant: JSON.stringify(variant),
    };
}
//# sourceMappingURL=media-lib.js.map