@varlet/cli 2.0.6 → 2.1.0-alpha.1667210582672

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/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/node/commands/lint.js

@@ -0,0 +1,42 @@
+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', '--cache', '.']);
+        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', '--cache']);
+        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',
+            '--cache',
+            '--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/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/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/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/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/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

@@ -10,7 +10,7 @@ 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 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>;

package/lib/node/compiler/compileScript.js

@@ -0,0 +1,141 @@
+import fse from 'fs-extra';
+import { transformAsync } from '@babel/core';
+import { bigCamelize } from '@varlet/shared';
+import { replaceExt } from '../shared/fsUtils.js';
+import { extractStyleDependencies, IMPORT_CSS_RE, IMPORT_LESS_RE, REQUIRE_CSS_RE, REQUIRE_LESS_RE, } from './compileStyle.js';
+import { resolve } from 'path';
+import { get } from 'lodash-es';
+import { getVarletConfig } from '../config/varlet.config.js';
+const { writeFileSync, readFileSync, removeSync, writeFile } = fse;
+export const IMPORT_VUE_PATH_RE = /((?<!['"`])import\s+.+from\s+['"]\s*\.{1,2}\/.+)\.vue(\s*['"`]);?(?!\s*['"`])/g;
+export const IMPORT_TS_PATH_RE = /((?<!['"`])import\s+.+from\s+['"]\s*\.{1,2}\/.+)\.ts(\s*['"`]);?(?!\s*['"`])/g;
+export const IMPORT_JSX_PATH_RE = /((?<!['"`])import\s+.+from\s+['"]\s*\.{1,2}\/.+)\.jsx(\s*['"`]);?(?!\s*['"`])/g;
+export const IMPORT_TSX_PATH_RE = /((?<!['"`])import\s+.+from\s+['"]\s*\.{1,2}\/.+)\.tsx(\s*['"`]);?(?!\s*['"`])/g;
+export const REQUIRE_VUE_PATH_RE = /(?<!['"`]\s*)(require\s*\(\s*['"]\s*\.{1,2}\/.+)\.vue(\s*['"`]\))(?!\s*['"`])/g;
+export const REQUIRE_TS_PATH_RE = /(?<!['"`]\s*)(require\s*\(\s*['"]\s*\.{1,2}\/.+)\.ts(\s*['"`]\))(?!\s*['"`])/g;
+export const REQUIRE_JSX_PATH_RE = /(?<!['"`]\s*)(require\s*\(\s*['"]\s*\.{1,2}\/.+)\.jsx(\s*['"`]\))(?!\s*['"`])/g;
+export const REQUIRE_TSX_PATH_RE = /(?<!['"`]\s*)(require\s*\(\s*['"]\s*\.{1,2}\/.+)\.tsx(\s*['"`]\))(?!\s*['"`])/g;
+const scriptReplacer = (_, p1, p2) => `${p1}.js${p2}`;
+export const replaceVueExt = (script) => script.replace(IMPORT_VUE_PATH_RE, scriptReplacer).replace(REQUIRE_VUE_PATH_RE, scriptReplacer);
+export const replaceTSExt = (script) => script.replace(IMPORT_TS_PATH_RE, scriptReplacer).replace(REQUIRE_TS_PATH_RE, scriptReplacer);
+export const replaceJSXExt = (script) => script.replace(IMPORT_JSX_PATH_RE, scriptReplacer).replace(REQUIRE_JSX_PATH_RE, scriptReplacer);
+export const replaceTSXExt = (script) => script.replace(IMPORT_TSX_PATH_RE, scriptReplacer).replace(REQUIRE_TSX_PATH_RE, scriptReplacer);
+export const moduleCompatible = async (script) => {
+    const moduleCompatible = get(await getVarletConfig(), 'moduleCompatible', {});
+    Object.keys(moduleCompatible).forEach((esm) => {
+        const commonjs = moduleCompatible[esm];
+        script = script.replace(esm, commonjs);
+    });
+    return script;
+};
+export async function compileScript(script, file) {
+    const modules = process.env.BABEL_MODULE;
+    if (modules === 'commonjs') {
+        script = await moduleCompatible(script);
+    }
+    let { code } = (await transformAsync(script, {
+        filename: file,
+    }));
+    code = extractStyleDependencies(file, code, modules === 'commonjs' ? REQUIRE_CSS_RE : IMPORT_CSS_RE);
+    code = extractStyleDependencies(file, code, modules === 'commonjs' ? REQUIRE_LESS_RE : IMPORT_LESS_RE);
+    code = replaceVueExt(code);
+    code = replaceTSXExt(code);
+    code = replaceJSXExt(code);
+    code = replaceTSExt(code);
+    removeSync(file);
+    writeFileSync(replaceExt(file, '.js'), code, 'utf8');
+}
+export async function compileScriptFile(file) {
+    const sources = readFileSync(file, 'utf-8');
+    await compileScript(sources, file);
+}
+export async function compileESEntry(dir, publicDirs) {
+    const imports = [];
+    const plugins = [];
+    const constInternalComponents = [];
+    const cssImports = [];
+    const publicComponents = [];
+    publicDirs.forEach((dirname) => {
+        const publicComponent = bigCamelize(dirname);
+        publicComponents.push(publicComponent);
+        imports.push(`import ${publicComponent}, * as ${publicComponent}Module from './${dirname}'`);
+        constInternalComponents.push(`export const _${publicComponent}Component = ${publicComponent}Module._${publicComponent}Component || {}`);
+        plugins.push(`${publicComponent}.install && app.use(${publicComponent})`);
+        cssImports.push(`import './${dirname}/style'`);
+    });
+    const install = `
+function install(app) {
+  ${plugins.join('\n  ')}
+}
+`;
+    const indexTemplate = `\
+${imports.join('\n')}\n
+${constInternalComponents.join('\n')}\n
+${install}
+export {
+  install,
+  ${publicComponents.join(',\n  ')}
+}
+
+export default {
+  install,
+  ${publicComponents.join(',\n  ')}
+}
+`;
+    const styleTemplate = `\
+${cssImports.join('\n')}
+`;
+    const umdTemplate = `\
+${imports.join('\n')}\n
+${cssImports.join('\n')}\n
+${install}
+export {
+  install,
+  ${publicComponents.join(',\n  ')}
+}
+
+export default {
+  install,
+  ${publicComponents.join(',\n  ')}
+}
+`;
+    await Promise.all([
+        writeFile(resolve(dir, 'index.js'), indexTemplate, 'utf-8'),
+        writeFile(resolve(dir, 'umdIndex.js'), umdTemplate, 'utf-8'),
+        writeFile(resolve(dir, 'style.js'), styleTemplate, 'utf-8'),
+    ]);
+}
+export async function compileCommonJSEntry(dir, publicDirs) {
+    const requires = [];
+    const plugins = [];
+    const cssRequires = [];
+    const publicComponents = [];
+    publicDirs.forEach((dirname) => {
+        const publicComponent = bigCamelize(dirname);
+        publicComponents.push(publicComponent);
+        requires.push(`var ${publicComponent} = require('./${dirname}')['default']`);
+        plugins.push(`${publicComponent}.install && app.use(${publicComponent})`);
+        cssRequires.push(`require('./${dirname}/style')`);
+    });
+    const install = `
+function install(app) {
+  ${plugins.join('\n  ')}
+}
+`;
+    const indexTemplate = `\
+${requires.join('\n')}\n
+${install}
+
+module.exports = {
+  install,
+  ${publicComponents.join(',\n  ')}
+}
+`;
+    const styleTemplate = `\
+${cssRequires.join('\n')}
+`;
+    await Promise.all([
+        writeFile(resolve(dir, 'index.js'), indexTemplate, 'utf-8'),
+        writeFile(resolve(dir, 'style.js'), styleTemplate, 'utf-8'),
+    ]);
+}