@paroicms/server/dist/rendered-site/helpers/liquid-tag-helpers.js

The ParoiCMS server

import { evalToken, Hash, Tag, } from "liquidjs";
import { isPromise } from "node:util/types";
import { extractRenderingContext } from "../../liquidjs-tools/liquidjs-utils.js";
export function createDeprecatedAssignLiquidTag(tagHandler, options = {}) {
    return class PaLiquidTag extends Tag {
        #varName;
        #args;
        #mainParameter;
        constructor(token, remainTokens, liquid) {
            super(token, remainTokens, liquid);
            this.#varName = this.tokenizer.readIdentifier().content;
            if (options.legacySyntax) {
                this.#mainParameter = undefined;
                this.#args = new Hash(token.args);
            }
            else {
                this.tokenizer.skipBlank();
                this.tokenizer.assert(this.tokenizer.peek() === "=", `Invalid syntax for tag "${token.name}", expected "="`);
                this.tokenizer.advance();
                const mainParamToken = this.tokenizer.readValue();
                this.tokenizer.assert(mainParamToken, 'expected value after "="');
                this.#mainParameter = mainParamToken;
                const remainingArgs = this.tokenizer.remaining();
                this.#args = new Hash(remainingArgs, liquid.options.keyValueSeparator);
            }
        }
        *render(ctx, _emitter) {
            const renderingContext = extractRenderingContext(ctx);
            const namedParameters = (yield this.#args.render(ctx)) ?? {};
            const mainParameter = this.#mainParameter
                ? yield evalToken(this.#mainParameter, ctx)
                : undefined;
            const result = tagHandler(renderingContext, {
                mainParameter,
                namedParameters,
                variableName: this.#varName,
            });
            const val = isGeneratorObject(result)
                ? yield* result
                : isPromise(result)
                    ? yield wrapLiquidTagPromise(renderingContext, result, tagHandler.name)
                    : result;
            ctx.bottom()[this.#varName] = val;
        }
    };
}
export async function wrapLiquidTagPromise(renderingContext, promise, tagName) {
    try {
        return await promise;
    }
    catch (error) {
        renderingContext.siteContext.logger.error(`Error in liquid tag "${tagName}"`, error);
        throw error;
    }
}
export function isGeneratorObject(value) {
    if (!value || typeof value !== "object")
        return false;
    const tag = Object.prototype.toString.call(value);
    if (tag === "[object Generator]")
        return true;
    const v = value;
    return (typeof v.next === "function" &&
        typeof v.throw === "function" &&
        typeof v.return === "function" &&
        v[Symbol.iterator] === v);
}
export function consumeGenerator(gen) {
    let last;
    for (const v of gen)
        last = v;
    return last;
}
//# sourceMappingURL=liquid-tag-helpers.js.map