@jsverse/transloco-keys-manager/keys-builder/template/pipe.extractor.js

Extract translatable keys from projects that uses Transloco

import { ParenthesizedExpression, tmplAstVisitAll, } from '@angular/compiler';
import { addKey } from '../add-key.js';
import { resolveAliasAndKey } from '../utils/resolvers.utils.js';
import { parseTemplate, resolveKeysFromLiteralMap } from './utils.js';
import { notNil } from '../../utils/validators.utils.js';
import { coerceArray } from '../../utils/collection.utils.js';
import { AstPipeCollector, isBindingPipe, isConditionalExpression, isLiteralExpression, isLiteralMap, TmplPipeCollector, } from '@jsverse/angular-utils';
export function pipeExtractor(config) {
    const parsedTemplate = parseTemplate(config);
    const tmplVisitor = new TmplPipeCollector('transloco');
    tmplAstVisitAll(tmplVisitor, parsedTemplate.nodes);
    const astVisitor = new AstPipeCollector();
    astVisitor.visitAll([...tmplVisitor.astTrees], {});
    const keysWithParams = astVisitor.pipes
        .get('transloco')
        ?.map((p) => resolveKeyAndParam(p.node))
        .flat()
        .filter(notNil);
    if (keysWithParams) {
        addKeysFromAst(keysWithParams, config);
    }
}
function resolveKeyNode(ast) {
    return coerceArray(ast)
        .flatMap((expression) => {
        if (isLiteralExpression(expression)) {
            return expression;
        }
        else if (isConditionalExpression(expression)) {
            return resolveKeyNode([expression.trueExp, expression.falseExp]);
        }
        else if (expression instanceof ParenthesizedExpression) {
            return resolveKeyNode(expression.expression);
        }
        return undefined;
    })
        .filter(notNil);
}
function resolveKeyAndParam(pipe, paramsNode) {
    const resolvedParams = paramsNode ?? pipe.args[0];
    if (isBindingPipe(pipe.exp)) {
        let nestedPipe = pipe;
        while (isBindingPipe(nestedPipe.exp)) {
            nestedPipe = nestedPipe.exp;
        }
        return resolveKeyAndParam(nestedPipe, resolvedParams);
    }
    else {
        const keyNodes = resolveKeyNode(pipe.exp);
        if (keyNodes.length >= 1) {
            return keyNodes.map((keyNode) => ({
                keyNode,
                paramsNode: resolvedParams,
            }));
        }
    }
    return null;
}
function addKeysFromAst(keys, config) {
    for (const { keyNode, paramsNode } of keys) {
        const [key, scopeAlias] = resolveAliasAndKey(keyNode.value, config.scopes);
        const params = isLiteralMap(paramsNode)
            ? resolveKeysFromLiteralMap(paramsNode)
            : [];
        addKey({
            ...config,
            keyWithoutScope: key,
            scopeAlias,
            params,
        });
    }
}
//# sourceMappingURL=pipe.extractor.js.map