@winner-fed/plugin-vant/dist/index.js

A Vant plugin adapted for WinJS, which supports automatic on-demand import of the Vant component library for both Vue 2 and Vue 3.

import { dirname, join } from "node:path";
import { VantResolver } from "@vant/auto-import-resolver";
import { deepmerge, resolve, winPath } from "@winner-fed/utils";
function kebabCase(key) {
    const result = key.replace(/([A-Z])/g, ' $1').trim();
    return result.split(' ').join('-').toLowerCase();
}
const vant2Function = [
    'Toast',
    'Dialog',
    'Notify',
    'ImagePreview'
];
function checkIfElementsExist(legacyFunction = []) {
    const sideEffects = [];
    legacyFunction.forEach((legacyFunc)=>{
        if (vant2Function.includes(legacyFunc)) sideEffects.push(legacyFunc);
    });
    return sideEffects;
}
function getSideEffects(dirName, moduleType, legacyFunction) {
    const sideEffects = [
        `vant/${moduleType}/${dirName}/style/index`
    ];
    const vanFunctions = checkIfElementsExist(legacyFunction);
    vanFunctions.forEach((dirName)=>{
        sideEffects.push(`vant/${moduleType}/${kebabCase(dirName)}/style/index`);
    });
    return sideEffects;
}
function VantVue2Resolver(legacyFunction = []) {
    const moduleType = 'es';
    return {
        type: 'component',
        resolve: (componentName)=>{
            if ('VanToast' === componentName || 'VanDialog' === componentName || 'VanNotify' === componentName || 'VanImagePreview' === componentName) return;
            if (componentName.startsWith('Van')) {
                const partialName = componentName.slice(3);
                const vanName = kebabCase(partialName);
                return {
                    from: `vant/${moduleType}/${vanName}`,
                    sideEffects: getSideEffects(vanName, moduleType, legacyFunction)
                };
            }
        }
    };
}
function VantVue2Imports(legacyFunction = []) {
    const sideEffects = [];
    legacyFunction.forEach((legacyFunc)=>{
        if (vant2Function.includes(legacyFunc)) sideEffects.push(legacyFunc);
    });
    if (sideEffects.length) return {
        'vant/es': sideEffects
    };
    return {};
}
function resolveProjectDep(opts) {
    var _opts_pkg_dependencies, _opts_pkg_devDependencies;
    if ((null == (_opts_pkg_dependencies = opts.pkg.dependencies) ? void 0 : _opts_pkg_dependencies[opts.dep]) || (null == (_opts_pkg_devDependencies = opts.pkg.devDependencies) ? void 0 : _opts_pkg_devDependencies[opts.dep])) return dirname(resolve.sync(`${opts.dep}/package.json`, {
        basedir: opts.cwd
    }));
}
const src = (api)=>{
    let pkgPath = '';
    try {
        pkgPath = resolveProjectDep({
            pkg: api.pkg,
            cwd: api.cwd,
            dep: 'vant'
        }) || dirname(require.resolve('vant/package.json'));
    } catch (e) {
        throw new Error("Can't find vant package. Please install antd first.");
    }
    function checkPkgPath() {
        if (!pkgPath) throw new Error("Can't find vant package. Please install antd first.");
    }
    const vantVersion = require(`${pkgPath}/package.json`).version;
    const isVant2 = null == vantVersion ? void 0 : vantVersion.startsWith('2.');
    api.modifyAppData((memo)=>{
        checkPkgPath();
        memo.vant = {
            pkgPath,
            version: vantVersion
        };
        return memo;
    });
    api.describe({
        key: 'vant',
        config: {
            schema ({ zod }) {
                return zod.object({
                    legacyFunction: zod.array(zod.string()).optional()
                });
            }
        },
        enableBy: api.EnableBy.config
    });
    if (isVant2) {
        var _api_userConfig_vant;
        const legacyFunction = (null == (_api_userConfig_vant = api.userConfig.vant) ? void 0 : _api_userConfig_vant.legacyFunction) || [];
        const unImports = {
            imports: [
                VantVue2Imports(legacyFunction)
            ],
            resolvers: [
                VantVue2Resolver(legacyFunction)
            ]
        };
        const unComponents = {
            resolvers: [
                VantVue2Resolver(legacyFunction)
            ]
        };
        api.userConfig.autoImport = deepmerge({
            unImports,
            unComponents
        }, api.userConfig.autoImport || {});
        api.onGenerateFiles(()=>{
            var _api_userConfig_vant;
            const components = (null == (_api_userConfig_vant = api.userConfig.vant) ? void 0 : _api_userConfig_vant.legacyFunction) || [];
            let componentsContent = '';
            let componentsStyleContent = '';
            let vueUseComponents = '';
            if (components.length) {
                vueUseComponents = 'Vue';
                componentsContent = "import { " + components.join(',') + " } from 'vant';";
                components.forEach((comp)=>{
                    componentsStyleContent += `import 'vant/es/${kebabCase(comp)}/style/index';\n`;
                    vueUseComponents += `.use(${comp})`;
                });
                vueUseComponents += ';';
                api.writeTmpFile({
                    path: 'plugin-vant/runtime.tsx',
                    content: `
import Vue from 'vue';

${componentsContent}

${componentsStyleContent}

${vueUseComponents}
      `,
                    noPluginDir: true
                });
            }
        });
        if (legacyFunction.length) api.addRuntimePlugin(()=>[
                winPath(join(api.paths.absTmpPath, 'plugin-vant/runtime.tsx'))
            ]);
    } else {
        const unImports = {
            resolvers: [
                VantResolver()
            ]
        };
        const unComponents = {
            resolvers: [
                VantResolver()
            ]
        };
        api.userConfig.autoImport = deepmerge({
            unImports,
            unComponents
        }, api.userConfig.autoImport || {});
    }
};
export { src as default };