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

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

"use strict";
var __webpack_require__ = {};
(()=>{
    __webpack_require__.d = (exports1, definition)=>{
        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
            enumerable: true,
            get: definition[key]
        });
    };
})();
(()=>{
    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
})();
(()=>{
    __webpack_require__.r = (exports1)=>{
        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
            value: 'Module'
        });
        Object.defineProperty(exports1, '__esModule', {
            value: true
        });
    };
})();
var __webpack_exports__ = {};
__webpack_require__.r(__webpack_exports__);
__webpack_require__.d(__webpack_exports__, {
    default: ()=>src
});
const external_node_path_namespaceObject = require("node:path");
const auto_import_resolver_namespaceObject = require("@vant/auto-import-resolver");
const utils_namespaceObject = require("@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 (0, external_node_path_namespaceObject.dirname)(utils_namespaceObject.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'
        }) || (0, external_node_path_namespaceObject.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 = (0, utils_namespaceObject.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(()=>[
                (0, utils_namespaceObject.winPath)((0, external_node_path_namespaceObject.join)(api.paths.absTmpPath, 'plugin-vant/runtime.tsx'))
            ]);
    } else {
        const unImports = {
            resolvers: [
                (0, auto_import_resolver_namespaceObject.VantResolver)()
            ]
        };
        const unComponents = {
            resolvers: [
                (0, auto_import_resolver_namespaceObject.VantResolver)()
            ]
        };
        api.userConfig.autoImport = (0, utils_namespaceObject.deepmerge)({
            unImports,
            unComponents
        }, api.userConfig.autoImport || {});
    }
};
exports["default"] = __webpack_exports__["default"];
for(var __webpack_i__ in __webpack_exports__)if (-1 === [
    "default"
].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
Object.defineProperty(exports, '__esModule', {
    value: true
});