@dcloudio/uni-cli-shared 0.0.1-nvue3.3030820220125001

package/dist/utils.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeParsePlugins = exports.normalizeMiniProgramFilename = exports.normalizeNodeModules = exports.removeExt = exports.normalizePagePath = exports.normalizeIdentifier = exports.checkElementNodeTag = exports.normalizePath = exports.isWindows = exports.isRunningWithYarnPnp = exports.hash = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const shared_1 = require("@vue/shared");
+var hash_sum_1 = require("hash-sum");
+Object.defineProperty(exports, "hash", { enumerable: true, get: function () { return __importDefault(hash_sum_1).default; } });
+const constants_1 = require("./constants");
+try {
+    exports.isRunningWithYarnPnp = Boolean(require('pnpapi'));
+}
+catch (_a) { }
+exports.isWindows = os_1.default.platform() === 'win32';
+function normalizePath(id) {
+    return exports.isWindows ? id.replace(/\\/g, '/') : id;
+}
+exports.normalizePath = normalizePath;
+function checkElementNodeTag(node, tag) {
+    return !!node && node.type === 1 /* ELEMENT */ && node.tag === tag;
+}
+exports.checkElementNodeTag = checkElementNodeTag;
+function normalizeIdentifier(str) {
+    return (0, shared_1.capitalize)((0, shared_1.camelize)(str.replace(/\//g, '-')));
+}
+exports.normalizeIdentifier = normalizeIdentifier;
+function normalizePagePath(pagePath, platform) {
+    const absoltePagePath = path_1.default.resolve(process.env.UNI_INPUT_DIR, pagePath);
+    let extnames = constants_1.PAGE_EXTNAME;
+    if (platform === 'app') {
+        extnames = constants_1.PAGE_EXTNAME_APP;
+    }
+    for (let i = 0; i < extnames.length; i++) {
+        const extname = extnames[i];
+        if (fs_1.default.existsSync(absoltePagePath + extname)) {
+            return pagePath + extname;
+        }
+    }
+    console.error(`${pagePath} not found`);
+}
+exports.normalizePagePath = normalizePagePath;
+function removeExt(str) {
+    return str.split('?')[0].replace(/\.\w+$/g, '');
+}
+exports.removeExt = removeExt;
+const NODE_MODULES_REGEX = /(\.\.\/)?node_modules/g;
+function normalizeNodeModules(str) {
+    str = normalizePath(str).replace(NODE_MODULES_REGEX, 'node-modules');
+    // HBuilderX 内置模块路径转换
+    str = str.replace(/.*\/plugins\/uniapp-cli-vite\/node[-_]modules/, 'node-modules');
+    if (process.env.UNI_PLATFORM === 'mp-alipay') {
+        str = str.replace('node-modules/@', 'node-modules/npm-scope-');
+    }
+    return str;
+}
+exports.normalizeNodeModules = normalizeNodeModules;
+function normalizeMiniProgramFilename(filename, inputDir) {
+    if (!inputDir || !path_1.default.isAbsolute(filename)) {
+        return normalizeNodeModules(filename);
+    }
+    return normalizeNodeModules(path_1.default.relative(inputDir, filename));
+}
+exports.normalizeMiniProgramFilename = normalizeMiniProgramFilename;
+function normalizeParsePlugins(importer, babelParserPlugins) {
+    const isTS = constants_1.EXTNAME_TS_RE.test(importer.split('?')[0]);
+    const plugins = [];
+    if (isTS) {
+        plugins.push('jsx');
+    }
+    if (babelParserPlugins)
+        plugins.push(...babelParserPlugins);
+    if (isTS)
+        plugins.push('typescript', 'decorators-legacy');
+    return plugins;
+}
+exports.normalizeParsePlugins = normalizeParsePlugins;

package/dist/vite/features.d.ts

@@ -0,0 +1,41 @@
+import type { ConfigEnv } from 'vite';
+export declare type FEATURE_DEFINES = ReturnType<typeof initFeatures>;
+interface InitFeaturesOptions {
+    pagesJson: UniApp.PagesJson;
+    manifestJson: any;
+    inputDir: string;
+    platform: UniApp.PLATFORM;
+    command: ConfigEnv['command'];
+    ssr: boolean;
+}
+export declare function initFeatures(options: InitFeaturesOptions): {
+    __VUE_OPTIONS_API__: boolean;
+    __VUE_PROD_DEVTOOLS__: boolean;
+    __UNI_FEATURE_WX__: boolean;
+    __UNI_FEATURE_WXS__: boolean;
+    __UNI_FEATURE_RPX__: boolean;
+    __UNI_FEATURE_PROMISE__: boolean;
+    __UNI_FEATURE_LONGPRESS__: boolean;
+    __UNI_FEATURE_I18N_EN__: boolean;
+    __UNI_FEATURE_I18N_ES__: boolean;
+    __UNI_FEATURE_I18N_FR__: boolean;
+    __UNI_FEATURE_I18N_ZH_HANS__: boolean;
+    __UNI_FEATURE_I18N_ZH_HANT__: boolean;
+    __UNI_FEATURE_UNI_CLOUD__: boolean;
+    __UNI_FEATURE_I18N_LOCALE__: boolean;
+    __UNI_FEATURE_NVUE__: boolean;
+    __UNI_FEATURE_ROUTER_MODE__: "\"hash\"" | "\"history\"";
+    __UNI_FEATURE_PAGES__: boolean;
+    __UNI_FEATURE_TABBAR__: boolean;
+    __UNI_FEATURE_TABBAR_MIDBUTTON__: boolean;
+    __UNI_FEATURE_TOPWINDOW__: boolean;
+    __UNI_FEATURE_LEFTWINDOW__: boolean;
+    __UNI_FEATURE_RIGHTWINDOW__: boolean;
+    __UNI_FEATURE_RESPONSIVE__: boolean;
+    __UNI_FEATURE_NAVIGATIONBAR__: boolean;
+    __UNI_FEATURE_PULL_DOWN_REFRESH__: boolean;
+    __UNI_FEATURE_NAVIGATIONBAR_BUTTONS__: boolean;
+    __UNI_FEATURE_NAVIGATIONBAR_SEARCHINPUT__: boolean;
+    __UNI_FEATURE_NAVIGATIONBAR_TRANSPARENT__: boolean;
+};
+export {};

package/dist/vite/features.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initFeatures = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const shared_1 = require("@vue/shared");
+function initProjectFeature({ inputDir }) {
+    const features = {
+        i18nLocale: false,
+        i18nEn: true,
+        i18nEs: true,
+        i18nFr: true,
+        i18nZhHans: true,
+        i18nZhHant: true,
+        uniCloud: false,
+    };
+    const localesDir = path_1.default.resolve(inputDir, 'locale');
+    if (fs_1.default.existsSync(localesDir)) {
+        if (fs_1.default.readdirSync(localesDir).find((file) => path_1.default.extname(file) === '.json')) {
+            features.i18nLocale = true;
+        }
+    }
+    if (process.env.UNI_CLOUD_PROVIDER) {
+        try {
+            const providers = JSON.parse(process.env.UNI_CLOUD_PROVIDER);
+            if (providers.length) {
+                features.uniCloud = true;
+            }
+        }
+        catch (e) { }
+    }
+    return features;
+}
+function initPagesFeature({ pagesJson, command, inputDir, ssr, }) {
+    const features = {
+        nvue: true,
+        pages: true,
+        tabBar: true,
+        tabBarMidButton: true,
+        topWindow: false,
+        leftWindow: false,
+        rightWindow: false,
+        navigationBar: true,
+        pullDownRefresh: false,
+        navigationBarButtons: true,
+        navigationBarSearchInput: true,
+        navigationBarTransparent: true,
+    };
+    const { tabBar, pages, topWindow, leftWindow, rightWindow, globalStyle } = pagesJson;
+    // ssr 时强制启用多页面（需要用到router）
+    if (!ssr && pages && pages.length === 1) {
+        features.pages = false;
+    }
+    if (!(tabBar && tabBar.list && tabBar.list.length)) {
+        features.tabBar = false;
+        features.tabBarMidButton = false;
+    }
+    if (features.tabBar && !tabBar.midButton) {
+        features.tabBarMidButton = false;
+    }
+    if (topWindow && topWindow.path) {
+        features.topWindow = true;
+    }
+    if (leftWindow && leftWindow.path) {
+        features.leftWindow = true;
+    }
+    if (rightWindow && rightWindow.path) {
+        features.rightWindow = true;
+    }
+    if (globalStyle.enablePullDownRefresh) {
+        features.pullDownRefresh = true;
+    }
+    else {
+        if (pages.find((page) => page.style && page.style.enablePullDownRefresh)) {
+            features.pullDownRefresh = true;
+        }
+    }
+    if (command === 'build') {
+        if (!pages.find((page) => fs_1.default.existsSync(path_1.default.resolve(inputDir, page.path + '.nvue')))) {
+            features.nvue = false;
+        }
+        let isNavigationCustom = false;
+        if (globalStyle.navigationBar.style === 'custom') {
+            isNavigationCustom = true; // 全局custom
+            if (pages.find((page) => page.style.navigationBar.style === 'default')) {
+                isNavigationCustom = false;
+            }
+        }
+        else {
+            // 所有页面均custom
+            if (pages.every((page) => page.style.navigationBar.style === 'custom')) {
+                isNavigationCustom = true;
+            }
+        }
+        if (isNavigationCustom) {
+            features.navigationBar = false;
+            features.navigationBarButtons = false;
+            features.navigationBarSearchInput = false;
+            features.navigationBarTransparent = false;
+        }
+        else {
+            if (!pages.find((page) => (0, shared_1.isArray)(page.style.navigationBar.buttons) &&
+                page.style.navigationBar.buttons.length)) {
+                features.navigationBarButtons = false;
+            }
+            if (!globalStyle.navigationBar.searchInput &&
+                !pages.find((page) => page.style.navigationBar.searchInput)) {
+                features.navigationBarSearchInput = false;
+            }
+            if (globalStyle.navigationBar.type !== 'transparent' &&
+                !pages.find((page) => page.style.navigationBar.type === 'transparent')) {
+                features.navigationBarTransparent = false;
+            }
+        }
+    }
+    return features;
+}
+function initManifestFeature({ manifestJson, command, platform, }) {
+    const features = {
+        wx: false,
+        wxs: true,
+        rpx: true,
+        promise: false,
+        longpress: true,
+        routerMode: '"hash"',
+        vueOptionsApi: true,
+        vueProdDevTools: false,
+    };
+    if (command === 'build') {
+        // TODO 需要预编译一遍？
+        // features.wxs = false
+        // features.longpress = false
+    }
+    if (manifestJson.h5 &&
+        manifestJson.h5.router &&
+        manifestJson.h5.router.mode === 'history') {
+        features.routerMode = '"history"';
+    }
+    // TODO other features
+    return features;
+}
+function initFeatures(options) {
+    const { wx, wxs, rpx, nvue, uniCloud, i18nEn, i18nEs, i18nFr, i18nZhHans, i18nZhHant, i18nLocale, vueOptionsApi, vueProdDevTools, pages, tabBar, tabBarMidButton, promise, longpress, routerMode, topWindow, leftWindow, rightWindow, navigationBar, pullDownRefresh, navigationBarButtons, navigationBarSearchInput, navigationBarTransparent, } = (0, shared_1.extend)(initManifestFeature(options), initPagesFeature(options), initProjectFeature(options));
+    const features = {
+        // vue
+        __VUE_OPTIONS_API__: vueOptionsApi,
+        __VUE_PROD_DEVTOOLS__: vueProdDevTools,
+        // uni
+        __UNI_FEATURE_WX__: wx,
+        __UNI_FEATURE_WXS__: wxs,
+        __UNI_FEATURE_RPX__: rpx,
+        __UNI_FEATURE_PROMISE__: promise,
+        __UNI_FEATURE_LONGPRESS__: longpress,
+        __UNI_FEATURE_I18N_EN__: i18nEn,
+        __UNI_FEATURE_I18N_ES__: i18nEs,
+        __UNI_FEATURE_I18N_FR__: i18nFr,
+        __UNI_FEATURE_I18N_ZH_HANS__: i18nZhHans,
+        __UNI_FEATURE_I18N_ZH_HANT__: i18nZhHant,
+        // 以下特性，编译器已自动识别是否需要启用
+        __UNI_FEATURE_UNI_CLOUD__: uniCloud,
+        __UNI_FEATURE_I18N_LOCALE__: i18nLocale,
+        __UNI_FEATURE_NVUE__: nvue,
+        __UNI_FEATURE_ROUTER_MODE__: routerMode,
+        __UNI_FEATURE_PAGES__: pages,
+        __UNI_FEATURE_TABBAR__: tabBar,
+        __UNI_FEATURE_TABBAR_MIDBUTTON__: tabBarMidButton,
+        __UNI_FEATURE_TOPWINDOW__: topWindow,
+        __UNI_FEATURE_LEFTWINDOW__: leftWindow,
+        __UNI_FEATURE_RIGHTWINDOW__: rightWindow,
+        __UNI_FEATURE_RESPONSIVE__: topWindow || leftWindow || rightWindow,
+        __UNI_FEATURE_NAVIGATIONBAR__: navigationBar,
+        __UNI_FEATURE_PULL_DOWN_REFRESH__: pullDownRefresh,
+        __UNI_FEATURE_NAVIGATIONBAR_BUTTONS__: navigationBarButtons,
+        __UNI_FEATURE_NAVIGATIONBAR_SEARCHINPUT__: navigationBarSearchInput,
+        __UNI_FEATURE_NAVIGATIONBAR_TRANSPARENT__: navigationBarTransparent, // 是否启用透明标题栏
+    };
+    // ssr nodejs features
+    if (options.ssr) {
+        Object.keys(features).forEach((name) => {
+            const value = features[name];
+            (0, shared_1.extend)(globalThis, {
+                [name]: (0, shared_1.isString)(value) ? JSON.parse(value) : value,
+            });
+        });
+    }
+    return features;
+}
+exports.initFeatures = initFeatures;

package/dist/vite/index.d.ts

@@ -0,0 +1,36 @@
+import type { Plugin } from 'vite';
+import type { EmittedAsset } from 'rollup';
+import type { ParserOptions } from '@vue/compiler-core';
+import type { CompilerOptions, SFCStyleCompileOptions, TemplateCompiler } from '@vue/compiler-sfc';
+import { UniViteCopyPluginOptions } from './plugins/copy';
+export declare const cssTarget = "chrome53";
+export interface CopyOptions {
+    /**
+     * 静态资源，配置的目录，在 uni_modules 中同样支持
+     */
+    assets?: string[];
+    targets?: UniViteCopyPluginOptions['targets'];
+}
+interface UniVitePluginUniOptions {
+    compiler?: TemplateCompiler;
+    styleOptions?: Pick<SFCStyleCompileOptions, 'postcssPlugins'>;
+    compilerOptions?: {
+        miniProgram?: {
+            emitFile?: (emittedFile: EmittedAsset) => string;
+        };
+        isNativeTag?: ParserOptions['isNativeTag'];
+        isCustomElement?: ParserOptions['isCustomElement'];
+        directiveTransforms?: CompilerOptions['directiveTransforms'];
+        nodeTransforms?: CompilerOptions['nodeTransforms'];
+    };
+    jsxOptions?: {
+        babelPlugins?: any[];
+    };
+    copyOptions?: CopyOptions | (() => CopyOptions);
+}
+export interface UniVitePlugin extends Plugin {
+    uni?: UniVitePluginUniOptions;
+}
+export * from './utils';
+export * from './plugins';
+export * from './features';

package/dist/vite/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cssTarget = void 0;
+exports.cssTarget = 'chrome53';
+__exportStar(require("./utils"), exports);
+__exportStar(require("./plugins"), exports);
+__exportStar(require("./features"), exports);

package/dist/vite/plugins/console.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from 'vite';
+import { FilterPattern } from '@rollup/pluginutils';
+export interface ConsoleOptions {
+    filename?: (filename: string) => string;
+    include?: FilterPattern;
+    exclude?: FilterPattern;
+}
+export declare function uniConsolePlugin(options: ConsoleOptions): Plugin;

package/dist/vite/plugins/console.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniConsolePlugin = void 0;
+const debug_1 = __importDefault(require("debug"));
+const pluginutils_1 = require("@rollup/pluginutils");
+const utils_1 = require("../utils");
+const console_1 = require("../../logs/console");
+const utils_2 = require("../../vite/utils/utils");
+const debugConsole = (0, debug_1.default)('uni:console');
+function uniConsolePlugin(options) {
+    const filter = (0, pluginutils_1.createFilter)(options.include, options.exclude);
+    let resolvedConfig;
+    return {
+        name: 'uni:console',
+        enforce: 'pre',
+        configResolved(config) {
+            resolvedConfig = config;
+        },
+        transform(code, id) {
+            if (!filter(id))
+                return null;
+            if (!(0, utils_1.isJsFile)(id))
+                return null;
+            let { filename } = (0, utils_1.parseVueRequest)(id);
+            if (options.filename) {
+                filename = options.filename(filename);
+            }
+            if (!filename) {
+                return null;
+            }
+            if (!code.includes('console.')) {
+                return null;
+            }
+            debugConsole(id);
+            return (0, console_1.rewriteConsoleExpr)(id, filename, code, (0, utils_2.withSourcemap)(resolvedConfig));
+        },
+    };
+}
+exports.uniConsolePlugin = uniConsolePlugin;

package/dist/vite/plugins/copy.d.ts

@@ -0,0 +1,11 @@
+import type { WatchOptions } from 'chokidar';
+import type { Plugin } from 'vite';
+import { FileWatcherOptions } from '../../watcher';
+export declare type UniViteCopyPluginTarget = Omit<FileWatcherOptions, 'verbose'> & {
+    watchOptions?: WatchOptions;
+};
+export interface UniViteCopyPluginOptions {
+    targets: UniViteCopyPluginTarget[];
+    verbose: boolean;
+}
+export declare function uniViteCopyPlugin({ targets, verbose, }: UniViteCopyPluginOptions): Plugin;

package/dist/vite/plugins/copy.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniViteCopyPlugin = void 0;
+const watcher_1 = require("../../watcher");
+const messages_1 = require("../../messages");
+function uniViteCopyPlugin({ targets, verbose, }) {
+    let resolvedConfig;
+    let inited = false;
+    return {
+        name: 'uni:copy',
+        apply: 'build',
+        configResolved(config) {
+            resolvedConfig = config;
+        },
+        writeBundle() {
+            if (inited) {
+                return;
+            }
+            if (resolvedConfig.build.ssr) {
+                return;
+            }
+            inited = true;
+            return new Promise((resolve) => {
+                Promise.all(targets.map(({ watchOptions, ...target }) => {
+                    return new Promise((resolve) => {
+                        new watcher_1.FileWatcher({
+                            verbose,
+                            ...target,
+                        }).watch({
+                            cwd: process.env.UNI_INPUT_DIR,
+                            ...watchOptions,
+                        }, (watcher) => {
+                            if (process.env.NODE_ENV !== 'development') {
+                                // 生产模式下，延迟 close，否则会影响 chokidar 初始化的 add 等事件
+                                setTimeout(() => {
+                                    watcher.close().then(() => resolve(void 0));
+                                }, 1000);
+                            }
+                            else {
+                                resolve(void 0);
+                            }
+                        }, () => {
+                            console.log(messages_1.M['dev.watching.end']);
+                        });
+                    });
+                })).then(() => resolve());
+            });
+        },
+    };
+}
+exports.uniViteCopyPlugin = uniViteCopyPlugin;

package/dist/vite/plugins/cssScoped.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from 'vite';
+interface UniCssScopedPluginOptions {
+    filter: (id: string) => boolean;
+}
+export declare function uniCssScopedPlugin({ filter }?: UniCssScopedPluginOptions): Plugin;
+export {};

package/dist/vite/plugins/cssScoped.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniCssScopedPlugin = void 0;
+const path_1 = __importDefault(require("path"));
+const debug_1 = __importDefault(require("debug"));
+const constants_1 = require("../../constants");
+const preprocess_1 = require("../../preprocess");
+const debugScoped = (0, debug_1.default)('uni:scoped');
+const SCOPED_RE = /<style\s[^>]*scoped[^>]*>/i;
+function addScoped(code) {
+    if (SCOPED_RE.test(code)) {
+        return code;
+    }
+    return code.replace(/(<style\b[^><]*)>/gi, '$1 scoped>');
+}
+function uniCssScopedPlugin({ filter } = { filter: () => false }) {
+    return {
+        name: 'uni:css-scoped',
+        enforce: 'pre',
+        transform(code, id) {
+            if (!filter(id))
+                return null;
+            debugScoped(id);
+            return {
+                code: addScoped(code),
+                map: null,
+            };
+        },
+        // 仅 h5
+        handleHotUpdate(ctx) {
+            if (!constants_1.EXTNAME_VUE.includes(path_1.default.extname(ctx.file))) {
+                return;
+            }
+            const scoped = !ctx.file.endsWith('App.vue');
+            debugScoped('hmr', ctx.file);
+            const oldRead = ctx.read;
+            ctx.read = async () => {
+                let code = await oldRead();
+                // hotUpdate preprocess
+                if (code.includes('#endif')) {
+                    code = (0, preprocess_1.preJs)((0, preprocess_1.preHtml)(code));
+                }
+                if (scoped) {
+                    code = addScoped(code);
+                }
+                return code;
+            };
+        },
+    };
+}
+exports.uniCssScopedPlugin = uniCssScopedPlugin;

package/dist/vite/plugins/dynamicImportPolyfill.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'vite';
+export declare function dynamicImportPolyfill(): Plugin;

package/dist/vite/plugins/dynamicImportPolyfill.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamicImportPolyfill = void 0;
+function dynamicImportPolyfill() {
+    return {
+        name: 'dynamic-import-polyfill',
+        renderDynamicImport() {
+            return {
+                left: '(',
+                right: ')',
+            };
+        },
+    };
+}
+exports.dynamicImportPolyfill = dynamicImportPolyfill;

package/dist/vite/plugins/index.d.ts

@@ -0,0 +1,10 @@
+export * from './cssScoped';
+export * from './copy';
+export * from './inject';
+export * from './mainJs';
+export * from './jsonJs';
+export * from './console';
+export * from './dynamicImportPolyfill';
+export { assetPlugin, getAssetHash } from './vitejs/plugins/asset';
+export { isCSSRequest, cssPlugin, cssPostPlugin, minifyCSS, cssLangRE, commonjsProxyRE, } from './vitejs/plugins/css';
+export { generateCodeFrame } from './vitejs/utils';

package/dist/vite/plugins/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCodeFrame = exports.commonjsProxyRE = exports.cssLangRE = exports.minifyCSS = exports.cssPostPlugin = exports.cssPlugin = exports.isCSSRequest = exports.getAssetHash = exports.assetPlugin = void 0;
+__exportStar(require("./cssScoped"), exports);
+__exportStar(require("./copy"), exports);
+__exportStar(require("./inject"), exports);
+__exportStar(require("./mainJs"), exports);
+__exportStar(require("./jsonJs"), exports);
+__exportStar(require("./console"), exports);
+__exportStar(require("./dynamicImportPolyfill"), exports);
+var asset_1 = require("./vitejs/plugins/asset");
+Object.defineProperty(exports, "assetPlugin", { enumerable: true, get: function () { return asset_1.assetPlugin; } });
+Object.defineProperty(exports, "getAssetHash", { enumerable: true, get: function () { return asset_1.getAssetHash; } });
+var css_1 = require("./vitejs/plugins/css");
+Object.defineProperty(exports, "isCSSRequest", { enumerable: true, get: function () { return css_1.isCSSRequest; } });
+Object.defineProperty(exports, "cssPlugin", { enumerable: true, get: function () { return css_1.cssPlugin; } });
+Object.defineProperty(exports, "cssPostPlugin", { enumerable: true, get: function () { return css_1.cssPostPlugin; } });
+Object.defineProperty(exports, "minifyCSS", { enumerable: true, get: function () { return css_1.minifyCSS; } });
+Object.defineProperty(exports, "cssLangRE", { enumerable: true, get: function () { return css_1.cssLangRE; } });
+Object.defineProperty(exports, "commonjsProxyRE", { enumerable: true, get: function () { return css_1.commonjsProxyRE; } });
+var utils_1 = require("./vitejs/utils");
+Object.defineProperty(exports, "generateCodeFrame", { enumerable: true, get: function () { return utils_1.generateCodeFrame; } });

package/dist/vite/plugins/inject.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin } from 'vite';
+import { FilterPattern } from '@rollup/pluginutils';
+declare type Injectment = string | [string, string];
+export interface InjectOptions {
+    sourceMap?: boolean;
+    callback?: (imports: Map<any, any>, mod: [string, string]) => void;
+    include?: FilterPattern;
+    exclude?: FilterPattern;
+    [str: string]: Injectment | FilterPattern | Boolean | Function | undefined;
+}
+export declare function uniViteInjectPlugin(name: string, options: InjectOptions): Plugin;
+export {};