@paroicms/server-image-cache-engine/dist/owner-transaction/owner-batch.js

The image variant engine that we use at Paroi.

import { generateResourceVersion } from "@paroicms/internal-server-lib";
import { fetchBatchOfStoredCacheItems } from "../internal/queries.js";
import { makeTaskKey, toTransactionCacheItem } from "../internal/utils.js";
export async function makeBatchOfImagesAvailable(otContext, inputs) {
    const { engineContext, ownerHandle, localCache } = otContext;
    const groups1 = groupInputsByImages(inputs);
    const groups2 = groupInputsByRequestedKeys(groups1);
    const list = await fetchBatchOfStoredCacheItems(engineContext, groups2.map((grouped) => ({
        mediaIds: grouped.images.map((image) => image.mediaId),
        requestedVariants: grouped.requestedVariants,
    })), ownerHandle);
    const fetchedVariants = new Map(list.map((v) => [makeTaskKey(v.variant), v]));
    for (const input of inputs) {
        localCache.set(input.taskKey, createTransactionCacheItem(input, fetchedVariants));
    }
}
function createTransactionCacheItem(input, fetchedVariants) {
    const existing = fetchedVariants.get(input.taskKey);
    if (existing)
        return toTransactionCacheItem(existing);
    const resourceVersion = generateResourceVersion();
    const { sourceImage, requestedVariant } = input;
    return {
        variant: {
            mediaId: sourceImage.mediaId,
            resourceVersion,
            mediaType: requestedVariant.mediaType,
            rawWidth: requestedVariant.rawWidth,
            rawHeight: requestedVariant.rawHeight,
            rawSizeName: requestedVariant.rawSizeName,
            slug: sourceImage.slug,
        },
    };
}
function groupInputsByRequestedKeys(groupedInputs) {
    const map = new Map();
    for (const entry of groupedInputs) {
        let group = map.get(entry.requestedListKey);
        if (!group) {
            group = {
                requestedVariants: entry.requestedVariants,
                images: new Map(),
            };
            map.set(entry.requestedListKey, group);
        }
        group.images.set(entry.image.mediaId, entry.image);
    }
    return Array.from(map.values()).map((group) => ({
        requestedVariants: group.requestedVariants,
        images: Array.from(group.images.values()),
    }));
}
function groupInputsByImages(inputs) {
    const map = new Map();
    for (let index = 0; index < inputs.length; ++index) {
        const input = inputs[index];
        const { sourceImage, requestedVariant } = input;
        let entry = map.get(sourceImage.mediaId);
        if (!entry) {
            entry = {
                image: sourceImage,
                requestedVariants: [],
                inputs: [],
            };
            map.set(sourceImage.mediaId, entry);
        }
        entry.inputs.push(input);
        if (entry.requestedVariants.findIndex((v) => v.rawSizeName === requestedVariant.rawSizeName &&
            v.mediaType === requestedVariant.mediaType) === -1) {
            entry.requestedVariants.push(requestedVariant);
        }
    }
    return Array.from(map.values()).map((entry) => {
        const list = entry.requestedVariants.map(makeRequestedImageVariantKey);
        const requestedListKey = JSON.stringify(list.sort());
        return {
            ...entry,
            requestedListKey,
        };
    });
}
function makeRequestedImageVariantKey(r) {
    return `${r.rawSizeName}:${r.mediaType}`;
}
//# sourceMappingURL=owner-batch.js.map