@varlet/cli 2.0.5 → 2.1.0-alpha.1666877950844

package/lib/{commands → node/commands}/dev.d.ts

@@ -1,5 +1,5 @@
-interface DevCommandOptions {
-    force?: boolean;
-}
-export declare function dev(options: DevCommandOptions): Promise<void>;
-export {};
+interface DevCommandOptions {
+    force?: boolean;
+}
+export declare function dev(options: DevCommandOptions): Promise<void>;
+export {};

package/lib/node/commands/dev.js

@@ -0,0 +1,38 @@
+import chokidar from 'chokidar';
+import fse from 'fs-extra';
+import logger from '../shared/logger.js';
+import { createServer } from 'vite';
+import { SRC_DIR, VARLET_CONFIG } from '../shared/constant.js';
+import { buildSiteEntry } from '../compiler/compileSiteEntry.js';
+import { getDevConfig } from '../config/vite.config.js';
+import { getVarletConfig } from '../config/varlet.config.js';
+import { merge } from 'lodash-es';
+const { ensureDirSync, pathExistsSync } = fse;
+let server;
+let watcher;
+async function startServer(force) {
+    const isRestart = Boolean(server);
+    logger.info(`${isRestart ? 'Res' : 'S'}tarting server...`);
+    // close all instance
+    server && (await server.close());
+    watcher && (await watcher.close());
+    // build all config
+    await buildSiteEntry();
+    const varletConfig = await getVarletConfig();
+    const devConfig = getDevConfig(varletConfig);
+    const inlineConfig = merge(devConfig, force ? { optimizeDeps: { force: true } } : {});
+    // create all instance
+    server = await createServer(inlineConfig);
+    await server.listen();
+    server.printUrls();
+    if (pathExistsSync(VARLET_CONFIG)) {
+        watcher = chokidar.watch(VARLET_CONFIG);
+        watcher.on('change', () => startServer(force));
+    }
+    logger.success(`\n${isRestart ? 'Res' : 'S'}tart successfully!!!`);
+}
+export async function dev(options) {
+    process.env.NODE_ENV = 'development';
+    ensureDirSync(SRC_DIR);
+    await startServer(options.force);
+}

package/lib/{commands → node/commands}/gen.d.ts

@@ -1,8 +1,8 @@
-interface GenCommandOptions {
-    name?: string;
-    i18n?: boolean;
-    sfc?: boolean;
-    tsx?: boolean;
-}
-export declare function gen(options: GenCommandOptions): Promise<void>;
-export {};
+interface GenCommandOptions {
+    name?: string;
+    i18n?: boolean;
+    sfc?: boolean;
+    tsx?: boolean;
+}
+export declare function gen(options: GenCommandOptions): Promise<void>;
+export {};

package/lib/node/commands/gen.js

@@ -0,0 +1,75 @@
+import logger from '../shared/logger.js';
+import fse from 'fs-extra';
+import inquirer from 'inquirer';
+import { resolve } from 'path';
+import { CLI_PACKAGE_JSON, CWD, GENERATORS_DIR } from '../shared/constant.js';
+const { copy, pathExistsSync, readFileSync, writeFileSync, rename } = fse;
+const { prompt } = inquirer;
+function syncVersion(name) {
+    const file = resolve(CWD, name, 'package.json');
+    const pkg = JSON.parse(readFileSync(file, 'utf-8'));
+    const cliPkg = JSON.parse(readFileSync(CLI_PACKAGE_JSON, 'utf-8'));
+    Object.keys(pkg.devDependencies).forEach((key) => {
+        if (key.startsWith('@varlet')) {
+            pkg.devDependencies[key] = `^${cliPkg.version}`;
+        }
+    });
+    pkg.files = ['es', 'lib', 'umd', 'highlight', 'types'];
+    writeFileSync(file, JSON.stringify(pkg, null, 2));
+}
+export async function gen(options) {
+    logger.title('\n📦📦 Generate cli application ! \n');
+    const { name } = options.name
+        ? options
+        : await prompt({
+            name: 'name',
+            message: 'Name of the generate application: ',
+            default: 'varlet-cli-app',
+        });
+    const dest = resolve(CWD, name);
+    if (pathExistsSync(dest)) {
+        logger.error(`${name} already exists and cannot be recreated...`);
+        return;
+    }
+    let codeStyle;
+    // Determine whether the parameter carries a coding style
+    if (options.sfc || options.tsx) {
+        codeStyle = options.sfc ? 'sfc' : 'tsx';
+    }
+    else {
+        const { style } = await prompt({
+            name: 'style',
+            type: 'list',
+            message: 'Please select your component library programming format',
+            choices: ['sfc', 'tsx'],
+        });
+        codeStyle = style;
+    }
+    const { i18n } = options.i18n
+        ? options
+        : await prompt({
+            name: 'i18n',
+            type: 'confirm',
+            message: 'Whether to use i18n?',
+            default: false,
+        });
+    const dirName = i18n ? 'i18n' : 'default';
+    const base = resolve(GENERATORS_DIR, 'base');
+    const configBase = resolve(GENERATORS_DIR, 'config', dirName, 'base');
+    const code = resolve(GENERATORS_DIR, 'config', dirName, codeStyle);
+    await copy(base, dest);
+    await copy(configBase, dest);
+    await copy(code, dest);
+    await rename(resolve(dest, '_gitignore'), resolve(dest, '.gitignore'));
+    syncVersion(name);
+    logger.success('✨ Application generated successfully!');
+    logger.info(`\
+  cd ${name}
+  pnpm install
+  pnpm dev`);
+    logger.success(`\
+=======================
+  Good luck have fun
+=======================\
+      `);
+}

package/lib/{commands → node/commands}/jest.d.ts

@@ -1,8 +1,8 @@
-interface JestCommandOptions {
-    watch?: boolean;
-    watchAll?: boolean;
-    component?: string;
-    clearCache?: boolean;
-}
-export declare function jest(cmd: JestCommandOptions): Promise<void>;
-export {};
+interface JestCommandOptions {
+    watch?: boolean;
+    watchAll?: boolean;
+    component?: string;
+    clearCache?: boolean;
+}
+export declare function jest(cmd: JestCommandOptions): Promise<void>;
+export {};

package/lib/node/commands/jest.js

@@ -0,0 +1,27 @@
+import logger from '../shared/logger.js';
+import jestModule from 'jest';
+import { CWD, JEST_CONFIG } from '../shared/constant.js';
+import { buildSiteEntry } from '../compiler/compileSiteEntry.js';
+const { runCLI } = jestModule;
+export async function jest(cmd) {
+    process.env.NODE_ENV = 'test';
+    const config = {
+        rootDir: CWD,
+        watch: cmd.watch,
+        watchAll: cmd.watchAll,
+        clearCache: cmd.clearCache,
+        config: JEST_CONFIG,
+        testRegex: cmd.component && `${cmd.component}/__tests__/.*.spec.[jt]s?$`,
+    };
+    await buildSiteEntry();
+    try {
+        const response = await runCLI(config, [CWD]);
+        if (!response.results.success && !cmd.watch) {
+            process.exit(1);
+        }
+    }
+    catch (e) {
+        logger.error(e.toString());
+        process.exit(1);
+    }
+}

package/lib/{commands → node/commands}/lint.d.ts

@@ -1 +1 @@
-export declare function lint(): Promise<void>;
+export declare function lint(): Promise<void>;

package/lib/node/commands/lint.js

@@ -0,0 +1,41 @@
+import execa from 'execa';
+import ora from 'ora';
+import { CWD, ESLINT_EXTENSIONS } from '../shared/constant.js';
+import { isDir } from '../shared/fsUtils.js';
+import { resolve } from 'path';
+export async function lint() {
+    let spinner;
+    try {
+        spinner = ora('prettier starting...').start();
+        await execa('prettier', ['--write', '.']);
+        spinner.succeed('prettier success');
+        spinner = ora('stylelint starting...').start();
+        const stylelintPattern = ['./src/**/*.vue', './src/**/*.css', './src/**/*.less'];
+        const hasPackages = isDir(resolve(CWD, 'packages'));
+        hasPackages && stylelintPattern.push('./packages/**/*.vue', './packages/**/*.css', './packages/**/*.less');
+        await execa('stylelint', [...stylelintPattern, '--fix']);
+        spinner.succeed('stylelint success');
+        spinner = ora('eslint starting...').start();
+        const eslintPatterns = [
+            './src',
+            './packages/varlet-cli/src',
+            './packages/varlet-ui/src',
+            './packages/varlet-icons/lib',
+            './packages/varlet-markdown-vite-plugin',
+            './packages/varlet-touch-emulator',
+            './packages/varlet-vscode-extension/src',
+        ];
+        const { stdout } = await execa('eslint', [
+            ...eslintPatterns.filter((pattern) => isDir(resolve(CWD, pattern))),
+            '--fix',
+            '--ext',
+            ESLINT_EXTENSIONS.join(),
+        ]);
+        const type = stdout ? 'warn' : 'succeed';
+        spinner[type](stdout || 'eslint success');
+    }
+    catch (e) {
+        spinner.fail(e.toString());
+        process.exit(1);
+    }
+}

package/lib/{commands → node/commands}/preview.d.ts

@@ -1 +1 @@
-export declare function preview(): Promise<void>;
+export declare function preview(): Promise<void>;

package/lib/node/commands/preview.js

@@ -0,0 +1,18 @@
+import fse from 'fs-extra';
+import logger from '../shared/logger.js';
+import execa from 'execa';
+import { SITE_OUTPUT_PATH } from '../shared/constant.js';
+const { pathExistsSync } = fse;
+export async function preview() {
+    var _a;
+    if (!pathExistsSync(SITE_OUTPUT_PATH)) {
+        logger.warning('Cannot find the site folder, you must first run the build command to build the document site');
+        return;
+    }
+    try {
+        await ((_a = execa.command('live-server --port=5500', { cwd: SITE_OUTPUT_PATH }).stdout) === null || _a === void 0 ? void 0 : _a.pipe(process.stdout));
+    }
+    catch (e) {
+        logger.error(e.toString());
+    }
+}

package/lib/{commands → node/commands}/release.d.ts

@@ -1,5 +1,5 @@
-interface ReleaseCommandOptions {
-    remote?: string;
-}
-export declare function release(options: ReleaseCommandOptions): Promise<void>;
-export {};
+interface ReleaseCommandOptions {
+    remote?: string;
+}
+export declare function release(options: ReleaseCommandOptions): Promise<void>;
+export {};

package/lib/node/commands/release.js

@@ -0,0 +1,146 @@
+import ora from 'ora';
+import fse from 'fs-extra';
+import execa from 'execa';
+import logger from '../shared/logger.js';
+import semver from 'semver';
+import glob from 'glob';
+import inquirer from 'inquirer';
+import { CWD } from '../shared/constant.js';
+import { resolve } from 'path';
+import { changelog } from './changelog.js';
+const { writeFileSync, readJSONSync } = fse;
+const { prompt } = inquirer;
+const releaseTypes = ['premajor', 'preminor', 'prepatch', 'major', 'minor', 'patch'];
+async function isWorktreeEmpty() {
+    const ret = await execa('git', ['status', '--porcelain']);
+    return !ret.stdout;
+}
+async function publish(preRelease) {
+    const s = ora().start('Publishing all packages');
+    const args = ['-r', 'publish', '--no-git-checks', '--access', 'public'];
+    preRelease && args.push('--tag', 'alpha');
+    const ret = await execa('pnpm', args);
+    if (ret.stderr && ret.stderr.includes('npm ERR!')) {
+        throw new Error('\n' + ret.stderr);
+    }
+    else {
+        s.succeed('Publish all packages successfully');
+        ret.stdout && logger.info(ret.stdout);
+    }
+}
+async function pushGit(version, remote = 'origin') {
+    const s = ora().start('Pushing to remote git repository');
+    await execa('git', ['add', '.']);
+    await execa('git', ['commit', '-m', `v${version}`]);
+    await execa('git', ['tag', `v${version}`]);
+    await execa('git', ['push', remote, `v${version}`]);
+    const ret = await execa('git', ['push']);
+    s.succeed('Push remote repository successfully');
+    ret.stdout && logger.info(ret.stdout);
+}
+function updateVersion(version) {
+    const packageJsons = glob.sync('packages/*/package.json');
+    packageJsons.push('package.json');
+    packageJsons.forEach((path) => {
+        const file = resolve(CWD, path);
+        const config = readJSONSync(file);
+        config.version = version;
+        writeFileSync(file, JSON.stringify(config, null, 2));
+    });
+}
+async function confirmRegistry() {
+    const registry = (await execa('npm', ['config', 'get', 'registry'])).stdout;
+    const name = 'Registry confirm';
+    const ret = await prompt([
+        {
+            name,
+            type: 'confirm',
+            message: `Current registry is: ${registry}`,
+        },
+    ]);
+    return ret[name];
+}
+async function confirmVersion(currentVersion, expectVersion) {
+    const name = 'Version confirm';
+    const ret = await prompt([
+        {
+            name,
+            type: 'confirm',
+            message: `All packages version ${currentVersion} -> ${expectVersion}:`,
+        },
+    ]);
+    return ret[name];
+}
+async function confirmRefs(remote = 'origin') {
+    var _a;
+    const { stdout } = await execa('git', ['remote', '-v']);
+    const reg = new RegExp(`${remote}\t(.*) \\(push`);
+    const repo = (_a = stdout.match(reg)) === null || _a === void 0 ? void 0 : _a[1];
+    const { stdout: branch } = await execa('git', ['branch', '--show-current']);
+    const name = 'Refs confirm';
+    const ret = await prompt([
+        {
+            name,
+            type: 'confirm',
+            message: `Current refs ${repo}:refs/for/${branch}`,
+        },
+    ]);
+    return ret[name];
+}
+async function getReleaseType() {
+    const name = 'Please select release type';
+    const ret = await prompt([
+        {
+            name,
+            type: 'list',
+            choices: releaseTypes,
+        },
+    ]);
+    return ret[name];
+}
+export async function release(options) {
+    try {
+        const currentVersion = readJSONSync(resolve(CWD, 'package.json')).version;
+        if (!currentVersion) {
+            logger.error('Your package is missing the version field');
+            return;
+        }
+        if (!(await isWorktreeEmpty())) {
+            logger.error('Git worktree is not empty, please commit changed');
+            return;
+        }
+        if (!(await confirmRefs(options.remote))) {
+            return;
+        }
+        if (!(await confirmRegistry())) {
+            return;
+        }
+        const type = await getReleaseType();
+        const isPreRelease = type.startsWith('pre');
+        let expectVersion = semver.inc(currentVersion, type, `alpha.${Date.now()}`);
+        expectVersion = isPreRelease ? expectVersion.slice(0, -2) : expectVersion;
+        if (!(await confirmVersion(currentVersion, expectVersion))) {
+            return;
+        }
+        updateVersion(expectVersion);
+        await publish(isPreRelease);
+        if (!isPreRelease) {
+            await changelog();
+            await pushGit(expectVersion, options.remote);
+        }
+        logger.success(`Release version ${expectVersion} successfully!`);
+        if (isPreRelease) {
+            try {
+                await execa('git', ['restore', '**/package.json']);
+                await execa('git', ['restore', 'package.json']);
+            }
+            catch (_a) {
+                logger.error('Restore package.json has failed, please restore manually');
+            }
+        }
+    }
+    catch (error) {
+        logger.error(error.toString());
+        process.exit(1);
+    }
+}

package/lib/{commands → node/commands}/vite.d.ts

@@ -1,3 +1,3 @@
-declare type ViteCommandMode = 'dev' | 'build';
-export declare function vite(mode: ViteCommandMode): Promise<void>;
-export {};
+declare type ViteCommandMode = 'dev' | 'build';
+export declare function vite(mode: ViteCommandMode): Promise<void>;
+export {};

package/lib/node/commands/vite.js

@@ -0,0 +1,13 @@
+import vue from '@vitejs/plugin-vue';
+import jsx from '@vitejs/plugin-vue-jsx';
+import { build, createServer } from 'vite';
+export async function vite(mode) {
+    const run = mode === 'build' ? build : createServer;
+    const result = await run({
+        plugins: [vue(), jsx()],
+    });
+    if (mode === 'dev') {
+        await result.listen();
+        result.printUrls();
+    }
+}

package/lib/{compiler → node/compiler}/compileModule.d.ts

@@ -1,5 +1,5 @@
-export declare function compileUMD(): Promise<void>;
-export declare function compileESMBundle(): Promise<void>;
-export declare function compileDir(dir: string): Promise<void>;
-export declare function compileFile(file: string): Promise<void>;
-export declare function compileModule(modules?: 'umd' | 'commonjs' | 'esm-bundle' | boolean): Promise<void>;
+export declare function compileUMD(): Promise<void>;
+export declare function compileESMBundle(): Promise<void>;
+export declare function compileDir(dir: string): Promise<void>;
+export declare function compileFile(file: string): Promise<void>;
+export declare function compileModule(modules?: 'umd' | 'commonjs' | 'esm-bundle' | boolean): Promise<void>;

package/lib/node/compiler/compileModule.js

@@ -0,0 +1,74 @@
+import fse from 'fs-extra';
+import { build } from 'vite';
+import { resolve } from 'path';
+import { EXAMPLE_DIR_NAME, TESTS_DIR_NAME, DOCS_DIR_NAME, SRC_DIR, ES_DIR, STYLE_DIR_NAME, LIB_DIR, } from '../shared/constant.js';
+import { getPublicDirs, isDir, isDTS, isLess, isScript, isSFC } from '../shared/fsUtils.js';
+import { compileSFC } from './compileSFC.js';
+import { compileESEntry, compileCommonJSEntry, compileScriptFile } from './compileScript.js';
+import { compileLess } from './compileStyle.js';
+import { getESMBundleConfig, getUMDConfig } from '../config/vite.config.js';
+import { getVarletConfig } from '../config/varlet.config.js';
+import { generateReference } from './compileTypes.js';
+const { copy, ensureFileSync, readdir, removeSync } = fse;
+export function compileUMD() {
+    return new Promise((resolve, reject) => {
+        getVarletConfig().then((varletConfig) => {
+            build(getUMDConfig(varletConfig))
+                .then(() => resolve())
+                .catch(reject);
+        });
+    });
+}
+export function compileESMBundle() {
+    return new Promise((resolve, reject) => {
+        getVarletConfig().then((varletConfig) => {
+            build(getESMBundleConfig(varletConfig))
+                .then(() => resolve())
+                .catch(reject);
+        });
+    });
+}
+export async function compileDir(dir) {
+    const dirs = await readdir(dir);
+    await Promise.all(dirs.map((filename) => {
+        const file = resolve(dir, filename);
+        [TESTS_DIR_NAME, EXAMPLE_DIR_NAME, DOCS_DIR_NAME].includes(filename) && removeSync(file);
+        if (isDTS(file) || filename === STYLE_DIR_NAME) {
+            return Promise.resolve();
+        }
+        return compileFile(file);
+    }));
+}
+export async function compileFile(file) {
+    isSFC(file) && (await compileSFC(file));
+    isScript(file) && (await compileScriptFile(file));
+    isLess(file) && (await compileLess(file));
+    isDir(file) && (await compileDir(file));
+}
+export async function compileModule(modules = false) {
+    if (modules === 'umd') {
+        await compileUMD();
+        return;
+    }
+    if (modules === 'esm-bundle') {
+        await compileESMBundle();
+        return;
+    }
+    process.env.BABEL_MODULE = modules === 'commonjs' ? 'commonjs' : 'module';
+    const dest = modules === 'commonjs' ? LIB_DIR : ES_DIR;
+    await copy(SRC_DIR, dest);
+    const moduleDir = await readdir(dest);
+    await Promise.all(moduleDir.map((filename) => {
+        const file = resolve(dest, filename);
+        isDir(file) && ensureFileSync(resolve(file, './style/index.js'));
+        return isDir(file) ? compileDir(file) : null;
+    }));
+    const publicDirs = await getPublicDirs();
+    if (modules === 'commonjs') {
+        await compileCommonJSEntry(dest, publicDirs);
+    }
+    else {
+        await compileESEntry(dest, publicDirs);
+    }
+    generateReference(dest);
+}

package/lib/{compiler → node/compiler}/compileSFC.d.ts

@@ -1,2 +1,2 @@
-export declare function injectRender(script: string, render: string): string;
-export declare function compileSFC(sfc: string): Promise<void>;
+export declare function injectRender(script: string, render: string): string;
+export declare function compileSFC(sfc: string): Promise<void>;

package/lib/node/compiler/compileSFC.js

@@ -0,0 +1,79 @@
+import fse from 'fs-extra';
+import hash from 'hash-sum';
+import { parse, resolve } from 'path';
+import { parse as parseSFC, compileTemplate, compileStyle } from '@vue/compiler-sfc';
+import { replaceExt, smartAppendFileSync } from '../shared/fsUtils.js';
+import { compileScript } from './compileScript.js';
+import { clearEmptyLine, compileLess, extractStyleDependencies, normalizeStyleDependency, STYLE_IMPORT_RE, } from './compileStyle.js';
+import logger from '../shared/logger.js';
+const { readFile, writeFileSync } = fse;
+const NORMAL_EXPORT_START_RE = /export\s+default\s+{/;
+const DEFINE_EXPORT_START_RE = /export\s+default\s+defineComponent\s*\(\s*{/;
+export function injectRender(script, render) {
+    if (DEFINE_EXPORT_START_RE.test(script.trim())) {
+        return script.trim().replace(DEFINE_EXPORT_START_RE, `${render}\nexport default defineComponent({
+  render,\
+    `);
+    }
+    if (NORMAL_EXPORT_START_RE.test(script.trim())) {
+        return script.trim().replace(NORMAL_EXPORT_START_RE, `${render}\nexport default {
+  render,\
+    `);
+    }
+    return script;
+}
+export async function compileSFC(sfc) {
+    const sources = await readFile(sfc, 'utf-8');
+    const { descriptor } = parseSFC(sources, { sourceMap: false });
+    const { script, scriptSetup, template, styles } = descriptor;
+    if (scriptSetup) {
+        logger.warning(`\n Varlet Cli does not support compiling script setup syntax\
+       \n  The error in ${sfc}`);
+        return;
+    }
+    // scoped
+    const hasScope = styles.some((style) => style.scoped);
+    const id = hash(sources);
+    const scopeId = hasScope ? `data-v-${id}` : '';
+    if (script) {
+        // template
+        const render = template &&
+            compileTemplate({
+                id,
+                source: template.content,
+                filename: sfc,
+                compilerOptions: {
+                    scopeId,
+                },
+            });
+        let { content } = script;
+        if (render) {
+            const { code } = render;
+            content = injectRender(content, code);
+        }
+        // script
+        await compileScript(content, sfc);
+        // style
+        for (let index = 0; index < styles.length; index++) {
+            const style = styles[index];
+            const file = replaceExt(sfc, `Sfc${index || ''}.${style.lang || 'css'}`);
+            const { base, dir } = parse(file);
+            const dependencyPath = normalizeStyleDependency(base, STYLE_IMPORT_RE);
+            const cssFile = resolve(dir, './style/index.js');
+            let { code } = compileStyle({
+                source: style.content,
+                filename: file,
+                id: scopeId,
+                scoped: style.scoped,
+            });
+            code = extractStyleDependencies(file, code, STYLE_IMPORT_RE);
+            writeFileSync(file, clearEmptyLine(code), 'utf-8');
+            smartAppendFileSync(cssFile, process.env.BABEL_MODULE === 'commonjs'
+                ? `require('${dependencyPath}.css')\n`
+                : `import '${dependencyPath}.css'\n`);
+            if (style.lang === 'less') {
+                await compileLess(file);
+            }
+        }
+    }
+}

package/lib/{compiler → node/compiler}/compileScript.d.ts

@@ -1,17 +1,17 @@
-export declare const IMPORT_VUE_PATH_RE: RegExp;
-export declare const IMPORT_TS_PATH_RE: RegExp;
-export declare const IMPORT_JSX_PATH_RE: RegExp;
-export declare const IMPORT_TSX_PATH_RE: RegExp;
-export declare const REQUIRE_VUE_PATH_RE: RegExp;
-export declare const REQUIRE_TS_PATH_RE: RegExp;
-export declare const REQUIRE_JSX_PATH_RE: RegExp;
-export declare const REQUIRE_TSX_PATH_RE: RegExp;
-export declare const replaceVueExt: (script: string) => string;
-export declare const replaceTSExt: (script: string) => string;
-export declare const replaceJSXExt: (script: string) => string;
-export declare const replaceTSXExt: (script: string) => string;
-export declare const moduleCompatible: (script: string) => string;
-export declare function compileScript(script: string, file: string): Promise<void>;
-export declare function compileScriptFile(file: string): Promise<void>;
-export declare function compileESEntry(dir: string, publicDirs: string[]): Promise<void>;
-export declare function compileCommonJSEntry(dir: string, publicDirs: string[]): Promise<void>;
+export declare const IMPORT_VUE_PATH_RE: RegExp;
+export declare const IMPORT_TS_PATH_RE: RegExp;
+export declare const IMPORT_JSX_PATH_RE: RegExp;
+export declare const IMPORT_TSX_PATH_RE: RegExp;
+export declare const REQUIRE_VUE_PATH_RE: RegExp;
+export declare const REQUIRE_TS_PATH_RE: RegExp;
+export declare const REQUIRE_JSX_PATH_RE: RegExp;
+export declare const REQUIRE_TSX_PATH_RE: RegExp;
+export declare const replaceVueExt: (script: string) => string;
+export declare const replaceTSExt: (script: string) => string;
+export declare const replaceJSXExt: (script: string) => string;
+export declare const replaceTSXExt: (script: string) => string;
+export declare const moduleCompatible: (script: string) => Promise<string>;
+export declare function compileScript(script: string, file: string): Promise<void>;
+export declare function compileScriptFile(file: string): Promise<void>;
+export declare function compileESEntry(dir: string, publicDirs: string[]): Promise<void>;
+export declare function compileCommonJSEntry(dir: string, publicDirs: string[]): Promise<void>;