@paroicms/server/dist/liquidjs-tools/liquidjs-drop.js

The ParoiCMS server

import { assignLoadDescriptor, } from "@paroicms/public-server-lib";
import { Drop } from "liquidjs";
import { promiseSymbol, valuesFnSymbol } from "./liquid-constants.js";
export function createLiquidDrop(renderingContext, optionsOrFn, { loadDescriptor } = {}) {
    const drop = Object.create(Drop.prototype);
    let options = typeof optionsOrFn === "function" ? undefined : optionsOrFn;
    const initOptions = async () => {
        if (typeof optionsOrFn !== "function")
            return optionsOrFn;
        if (!options) {
            const resolvedOptions = await optionsOrFn();
            options = resolvedOptions;
        }
        return options;
    };
    drop[valuesFnSymbol] = async () => (await initOptions()).values;
    if (loadDescriptor)
        assignLoadDescriptor(drop, loadDescriptor);
    drop.liquidMethodMissing = async (name) => {
        const options = typeof optionsOrFn === "function" ? await initOptions() : optionsOrFn;
        const { renderingCacheKey, values } = options;
        const { siteContext } = renderingContext;
        const val = values[name];
        if (typeof val !== "function")
            return val;
        try {
            return await loadOrFromRenderingCache(renderingContext, `${renderingCacheKey}:${name}`, val);
        }
        catch (error) {
            siteContext.logger.error(`Error when generating '${name}':`, error);
            throw error;
        }
    };
    return drop;
}
export async function loadOrFromRenderingCache(renderingContext, renderingCacheKey, load) {
    const cacheVal = renderingContext.getValueFromCache(renderingCacheKey);
    if (cacheVal.found)
        return cacheVal.val;
    const result = await load();
    renderingContext.setValueIntoCache(renderingCacheKey, result);
    return result;
}
export function createLiquidDropFromPromise({ renderingContext, renderingCacheKey, value, }) {
    const { siteContext } = renderingContext;
    const drop = Object.create(Drop.prototype);
    drop.liquidMethodMissing = async (name) => {
        const val = (await value)[name];
        if (typeof val !== "function")
            return val;
        try {
            return await loadOrFromRenderingCache(renderingContext, `${renderingCacheKey}:${name}`, val);
        }
        catch (error) {
            siteContext.logger.error(`Error when generating '${name}':`, error);
            throw error;
        }
    };
    drop[promiseSymbol] = value;
    return drop;
}
//# sourceMappingURL=liquidjs-drop.js.map