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

The ParoiCMS server

import { Hash, Tag, evalToken, } from "liquidjs";
import { isPromise } from "node:util/types";
import { extractRenderingContext } from "../../liquidjs-tools/liquidjs-utils.js";
export function createAssignLiquidTag(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 mainParamValue = this.tokenizer.readFilteredValue();
                this.tokenizer.assert(mainParamValue, 'expected value after "="');
                this.#mainParameter = mainParamValue;
                this.#args = new Hash(this.tokenizer, 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 = isIterable(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 createInjectHtmlLiquidTag(tagHandler) {
    return class PaLiquidTag extends Tag {
        #args;
        constructor(token, remainTokens, liquid) {
            super(token, remainTokens, liquid);
            this.#args = new Hash(token.args);
        }
        *render(ctx, emitter) {
            const renderingContext = extractRenderingContext(ctx);
            const parameters = (yield this.#args.render(ctx)) ?? {};
            const result = tagHandler(renderingContext, parameters);
            const val = typeof result === "string" ? result : yield result;
            emitter.write(val);
        }
    };
}
function isIterable(value) {
    return (!!value &&
        typeof value === "object" &&
        Symbol.iterator in value &&
        typeof value[Symbol.iterator] === "function");
}
//# sourceMappingURL=liquid-tag-helpers.js.map