@liip/esbuild-plugin-ast-vue/dist/plugin.js

Esbuild plugin to parse Vue AST

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.esbuildAstParserVue = esbuildAstParserVue;
const promises_1 = require("node:fs/promises");
const node_url_1 = require("node:url");
const ast_parsers_1 = require("@liip/ast-parsers");
const entry_1 = require("./entry");
const script_1 = require("./script");
const style_1 = require("./style");
const template_1 = require("./template");
const utils_1 = require("./utils");
(0, utils_1.validateDependency)();
function esbuildAstParserVue({ templateOptions, scriptOptions, styleOptions, visitors, tsTransformers, templateVisitor, scriptNamespace, }) {
    return {
        name: 'astParserVue',
        setup(build) {
            const { sourcemap } = build.initialOptions;
            const isProd = process.env.NODE_ENV === 'production';
            const tsConfig = (0, ast_parsers_1.loadTsConfig)('./tsconfig.json');
            build.onLoad({ filter: /\.vue$/ }, async (args) => {
                const source = await (0, promises_1.readFile)(args.path, 'utf8');
                const { code, errors } = (0, entry_1.loadEntry)({
                    source,
                    filename: args.path,
                    sourcemap: !!sourcemap,
                });
                return {
                    contents: code,
                    errors,
                };
            });
            /**
             * Script can import other dependencies and we don´t want to place
             * them in a specific namespace
             */
            build.onResolve({ filter: /\.vue\?type=script/ }, (args) => {
                const resolved = {
                    path: args.path,
                };
                if (scriptNamespace) {
                    resolved.namespace = scriptNamespace;
                }
                return resolved;
            });
            build.onLoad({ filter: /\.vue\?type=script/ }, (args) => {
                const { filename, dirname } = (0, utils_1.resolvePath)(args.path);
                const { code, error, isTs } = (0, script_1.resolveScript)({
                    filename,
                    scriptOptions,
                    templateOptions,
                    isProd,
                    sourcemap: !!sourcemap,
                });
                if (isTs && tsConfig) {
                    return {
                        contents: (0, ast_parsers_1.tsParser)({
                            path: args.path,
                            source: code,
                            transformers: tsTransformers,
                            tsConfig,
                        }),
                        loader: 'ts',
                        resolveDir: dirname,
                        errors: error,
                    };
                }
                const availableVisitors = [];
                if (visitors) {
                    (Array.isArray(visitors) ? visitors : [visitors]).forEach((visitor) => {
                        availableVisitors.push(visitor);
                    });
                }
                if (templateVisitor) {
                    availableVisitors.push(templateVisitor);
                }
                return {
                    contents: (0, ast_parsers_1.jsParser)({
                        source: code,
                        file: args.path,
                        visitors: availableVisitors,
                    }).code,
                    errors: error,
                    resolveDir: dirname,
                    loader: 'js',
                };
            });
            build.onResolve({ filter: /\.vue\?type=template/ }, (args) => {
                return {
                    path: args.path,
                    namespace: 'vue-template',
                };
            });
            build.onLoad({ filter: /.*/, namespace: 'vue-template' }, (args) => {
                const { filename, dirname } = (0, utils_1.resolvePath)(args.path);
                const { code, errors } = (0, template_1.resolveTemplate)({
                    filename,
                    options: templateOptions,
                    isProd,
                });
                return {
                    contents: (0, ast_parsers_1.jsParser)({
                        source: code,
                        file: args.path,
                        visitors: templateVisitor,
                    }).code,
                    pluginData: { code },
                    errors,
                    resolveDir: dirname,
                };
            });
            build.onResolve({ filter: /\.vue\?type=style/ }, (args) => {
                return {
                    path: args.path,
                    namespace: 'vue-style',
                };
            });
            build.onLoad({ filter: /.*/, namespace: 'vue-style' }, async (args) => {
                const { filename, dirname, query } = (0, utils_1.resolvePath)(args.path);
                const params = new node_url_1.URLSearchParams(query);
                const moduleWithNameImport = !!(params.get('isModule') && params.get('isNameImport'));
                const { styleCode, errors } = await (0, style_1.resolveStyle)({
                    filename,
                    styleOptions,
                    index: Number(params.get('index')),
                    isModule: !!params.get('isModule'),
                    moduleWithNameImport,
                    isProd,
                });
                return {
                    contents: styleCode,
                    errors,
                    resolveDir: dirname,
                    loader: moduleWithNameImport ? 'json' : 'css',
                };
            });
        },
    };
}
//# sourceMappingURL=plugin.js.map