@maple-design/cli-vue 0.0.0-stage → 1.1.0

package/lib/node/config/vite.config.js

@@ -0,0 +1,209 @@
+import { createRequire } from 'node:module';
+import { resolve } from 'path';
+import { MapleResolver, MapleStyleImports } from '@maple-design/resolver-vue';
+import { isArray } from '@maple-design/shared-vue';
+import { copy, html, inlineCss, markdown } from '@maple-design/vite-plugins-vue';
+import { browserTargets } from '@sparknest/ui-build-vue/browser-targets';
+import vue from '@vitejs/plugin-vue';
+import jsx from '@vitejs/plugin-vue-jsx';
+import AutoImport from 'unplugin-auto-import/vite';
+import Components from 'unplugin-vue-components/vite';
+import { ES_DIR, EXTENSION_ENTRY, SITE_CONFIG, SITE_DIR, SITE_MOBILE_ROUTES, SITE_OUTPUT_PATH, SITE_PC_ROUTES, SITE_PUBLIC_PATH, SRC_DIR, VITE_RESOLVE_EXTENSIONS, } from '../shared/constant.js';
+import { createSiteImportPlugin, createSiteResolver, getSiteComponentExcludes, getWorkspaceSourceAliases, } from './site-resolver.js';
+const uiDocPreviewEntry = createRequire(import.meta.url).resolve('@sparknest/ui-doc-preview-vue');
+export function getHtmlInject(inject) {
+    const getContent = (injectKey, position) => inject[injectKey]?.filter((point) => point.position === position).map((point) => point.content) ?? [];
+    return {
+        head: {
+            start: getContent('head', 'start'),
+            end: getContent('head', 'end'),
+            scriptStart: getContent('head', 'script-start'),
+        },
+        body: {
+            start: getContent('body', 'start'),
+            end: getContent('body', 'end'),
+            scriptStart: getContent('body', 'script-start'),
+        },
+    };
+}
+export function getPlugins(mapleConfig) {
+    const { vitePlugins = [] } = mapleConfig;
+    // Resolve on-demand component styles from source via alias during docs/dev.
+    const resolverOptions = { importStyle: true };
+    const plugins = [
+        MapleStyleImports(resolverOptions),
+        createSiteImportPlugin(SRC_DIR),
+        vue({
+            include: [/\.vue$/, /\.md$/],
+        }),
+        jsx(),
+        Components({
+            resolvers: [createSiteResolver(SRC_DIR, resolverOptions)],
+            exclude: getSiteComponentExcludes(SRC_DIR),
+            dts: false,
+        }),
+        AutoImport({
+            exclude: getSiteComponentExcludes(SRC_DIR),
+            resolvers: [MapleResolver({ ...resolverOptions, autoImport: true })],
+            dts: false,
+        }),
+        markdown({ style: mapleConfig?.highlight?.style }),
+        copy({ paths: mapleConfig?.copy || [] }),
+        html({
+            data: {
+                logo: mapleConfig?.logo,
+                baidu: mapleConfig?.analysis?.baidu,
+                pcTitle: mapleConfig?.seo?.title ?? '',
+                pcDescription: mapleConfig?.seo?.description ?? '',
+                pcKeywords: mapleConfig?.seo?.keywords ?? '',
+                pcHtmlInject: getHtmlInject(mapleConfig?.pc?.htmlInject || {}),
+                mobileTitle: mapleConfig?.seo?.title ?? '',
+                mobileDescription: mapleConfig?.seo?.description ?? '',
+                mobileKeywords: mapleConfig?.seo?.keywords ?? '',
+                mobileHtmlInject: getHtmlInject(mapleConfig?.mobile?.htmlInject || {}),
+            },
+        }),
+    ];
+    if (isArray(vitePlugins)) {
+        return [...plugins, ...vitePlugins];
+    }
+    return vitePlugins(plugins);
+}
+export function getDevConfig(mapleConfig) {
+    const { alias = {}, host } = mapleConfig;
+    const resolveAlias = Object.entries(alias).reduce((resolveAlias, [key, value]) => {
+        const isRelative = value.startsWith('.');
+        resolveAlias[key] = isRelative ? resolve(SRC_DIR, value) : value;
+        return resolveAlias;
+    }, {});
+    return {
+        configFile: false,
+        root: SITE_DIR,
+        // Browser fixtures use the package-level Vite cache; keep docs prebundles independent.
+        cacheDir: resolve(SITE_DIR, '../cache/vite-docs'),
+        resolve: {
+            dedupe: ['vue'],
+            extensions: VITE_RESOLVE_EXTENSIONS,
+            alias: [
+                { find: '@sparknest/ui-doc-preview-vue', replacement: uiDocPreviewEntry },
+                ...Object.entries(resolveAlias).map(([find, replacement]) => ({ find, replacement })),
+                ...getWorkspaceSourceAliases(SRC_DIR),
+                { find: '@config', replacement: SITE_CONFIG },
+                { find: '@maple-theme', replacement: resolve(SRC_DIR, 'style/theme/css-variables.less') },
+                { find: '@maple-foundation', replacement: resolve(SRC_DIR, 'style/index.less') },
+                { find: '@pc-routes', replacement: SITE_PC_ROUTES },
+                { find: '@mobile-routes', replacement: SITE_MOBILE_ROUTES },
+                {
+                    find: /^@maple-design\/ui-vue$/,
+                    replacement: resolve(SRC_DIR, 'index.ts'),
+                },
+                {
+                    find: /^@maple-design\/ui-vue\/style$/,
+                    replacement: resolve(SRC_DIR, 'style/index.less'),
+                },
+                {
+                    find: /^@maple-design\/ui-vue\/(.+)\/style$/,
+                    replacement: resolve(SRC_DIR, '$1/style'),
+                },
+            ],
+        },
+        css: {
+            preprocessorOptions: {
+                less: {
+                    javascriptEnabled: true,
+                },
+            },
+        },
+        server: {
+            port: mapleConfig?.port,
+            // Never silently create a second docs writer against the same .maple tree.
+            strictPort: true,
+            host: host === 'localhost' ? '0.0.0.0' : host,
+            proxy: mapleConfig?.proxy || {},
+        },
+        publicDir: SITE_PUBLIC_PATH,
+        plugins: getPlugins(mapleConfig),
+    };
+}
+export function getBuildConfig(mapleConfig) {
+    const devConfig = getDevConfig(mapleConfig);
+    return {
+        ...devConfig,
+        base: './',
+        build: {
+            outDir: SITE_OUTPUT_PATH,
+            reportCompressedSize: false,
+            emptyOutDir: true,
+            target: [...browserTargets],
+            cssTarget: [...browserTargets],
+            rollupOptions: {
+                input: {
+                    main: resolve(SITE_DIR, 'index.html'),
+                    mobile: resolve(SITE_DIR, 'mobile.html'),
+                },
+            },
+        },
+    };
+}
+export function getBundleConfig(mapleConfig, buildOptions) {
+    const plugins = [];
+    const name = mapleConfig?.name;
+    const { external = [], globals = {} } = mapleConfig?.bundle || {};
+    const { fileName, cssFileName, output, format, emptyOutDir, removeEnv } = buildOptions;
+    if (format === 'umd') {
+        plugins.push(inlineCss({
+            jsFile: resolve(output, fileName),
+            cssFile: resolve(output, `${cssFileName}.css`),
+        }));
+    }
+    return {
+        configFile: false,
+        logLevel: 'silent',
+        define: removeEnv
+            ? {
+                'process.env.NODE_ENV': JSON.stringify('production'),
+            }
+            : undefined,
+        plugins,
+        build: {
+            minify: format === 'cjs' ? false : 'esbuild',
+            emptyOutDir,
+            copyPublicDir: false,
+            lib: {
+                name,
+                formats: [format],
+                fileName: () => fileName,
+                cssFileName,
+                entry: resolve(ES_DIR, 'index.bundle.mjs'),
+            },
+            rollupOptions: {
+                external: ['vue', ...external],
+                output: {
+                    dir: output,
+                    exports: 'named',
+                    globals: {
+                        vue: 'Vue',
+                        ...globals,
+                    },
+                },
+            },
+        },
+    };
+}
+export function getExtensionConfig(mode) {
+    return {
+        configFile: false,
+        build: {
+            sourcemap: mode === 'dev' ? 'inline' : false,
+            watch: mode === 'dev' ? {} : null,
+            lib: {
+                entry: EXTENSION_ENTRY,
+                fileName: 'extension',
+                formats: ['cjs'],
+            },
+            rollupOptions: {
+                external: ['vscode'],
+            },
+        },
+    };
+}

package/lib/node/config/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/lib/node/config/vitest.config.js

@@ -0,0 +1,54 @@
+import { cpus } from 'os';
+import { dirname as pathDirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import vue from '@vitejs/plugin-vue';
+import jsx from '@vitejs/plugin-vue-jsx';
+import { configDefaults, defineConfig } from 'vitest/config';
+import { SRC_DIR, VITE_RESOLVE_EXTENSIONS } from '../shared/constant.js';
+const configDir = pathDirname(fileURLToPath(import.meta.url));
+const cpuNum = Math.max(cpus().length - 1, 1);
+export default defineConfig({
+    server: { host: '127.0.0.1' },
+    resolve: {
+        extensions: VITE_RESOLVE_EXTENSIONS,
+        // Demo imports must resolve to the source under test, not require a prior library build.
+        alias: [{ find: /^@maple-design\/ui-vue$/, replacement: resolve(SRC_DIR, 'index.ts') }],
+    },
+    plugins: [vue(), jsx()],
+    test: {
+        // Large component suites create a jsdom per file; bound their memory/IO
+        // pressure so ordinary test commands remain stable alongside type checks.
+        maxWorkers: Math.min(cpuNum, 4),
+        minWorkers: 1,
+        // Test authored component sources only; .maple contains copied CLI/site tests.
+        include: configDefaults.include.map((pattern) => `src/${pattern}`),
+        environment: 'jsdom',
+        setupFiles: [resolve(configDir, 'vitest.setup.js')],
+        coverage: {
+            provider: 'istanbul',
+            exclude: [
+                '**/*.d.ts',
+                '**/*.md',
+                '**/example/**',
+                '**/__tests__/**',
+                'node_modules/**',
+                '.maple/**',
+                'es/**',
+                'lib/**',
+                'site/**',
+                'umd/**',
+                'docs/**',
+                'coverage/**',
+                'types/**',
+                'shims/**',
+                'maple.config.mjs',
+            ],
+        },
+        globals: true,
+        poolOptions: {
+            vmThreads: {
+                memoryLimit: Math.min((1 / cpuNum) * 2, 0.2),
+            },
+        },
+    },
+});

package/lib/node/config/vitest.setup.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/node/config/vitest.setup.js

@@ -0,0 +1,8 @@
+import { afterEach } from 'vitest';
+afterEach(() => {
+    if (typeof document === 'undefined') {
+        return;
+    }
+    // Teleport popups attach to document.body; remove leftovers when a test throws before unmount.
+    document.body.querySelectorAll('.mp-trigger-popup, .mp-popup, .mp-overlay, .mp-menu').forEach((el) => el.remove());
+});

package/lib/node/index.d.ts

@@ -0,0 +1,13 @@
+export { defineConfig } from './config/maple.config.js';
+export * from './release/index.js';
+export * from './commands/dev.js';
+export * from './commands/build.js';
+export * from './commands/compile.js';
+export * from './commands/gen.js';
+export * from './commands/test.js';
+export * from './commands/create.js';
+export * from './commands/preview.js';
+export * from './commands/vite.js';
+export * from './commands/extension.js';
+export * from './commands/checklist.js';
+export * from './commands/styleVars.js';

package/lib/node/index.js

@@ -0,0 +1,13 @@
+export { defineConfig } from './config/maple.config.js';
+export * from './release/index.js';
+export * from './commands/dev.js';
+export * from './commands/build.js';
+export * from './commands/compile.js';
+export * from './commands/gen.js';
+export * from './commands/test.js';
+export * from './commands/create.js';
+export * from './commands/preview.js';
+export * from './commands/vite.js';
+export * from './commands/extension.js';
+export * from './commands/checklist.js';
+export * from './commands/styleVars.js';

package/lib/node/release/index.d.ts

@@ -0,0 +1,20 @@
+export declare const COMMIT_MESSAGE_RE: RegExp;
+export declare function getCommitMessage(gitParams: string): string;
+export declare function isVersionCommitMessage(commitMessage: string): boolean;
+export interface CommitLintOptions {
+    commitMessagePath?: string;
+    commitMessageRe?: string;
+    errorMessage?: string;
+    warningMessage?: string;
+}
+export declare function commitLint(options: CommitLintOptions): void;
+export interface ChangelogOptions {
+    releaseCount?: string;
+    file?: string;
+}
+export declare function changelog(options: ChangelogOptions): Promise<void>;
+export interface ReleaseOptions {
+    remote?: string;
+    task?: () => Promise<void>;
+}
+export declare function release(options: ReleaseOptions): Promise<void>;

package/lib/node/release/index.js

@@ -0,0 +1,147 @@
+import fs from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { input, select } from '@inquirer/prompts';
+import conventionalChangelog from 'conventional-changelog';
+import fse from 'fs-extra';
+import { createSpinner } from 'nanospinner';
+import pc from 'picocolors';
+import semver from 'semver';
+const { green, red, yellow } = pc;
+// ── Commit Message Regex ──────────────────────────────────────────
+// Conventional Commits: type(scope): description
+export const COMMIT_MESSAGE_RE = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert|release|wip)(\(.+\))?:.{1,}/;
+// ── Helpers ───────────────────────────────────────────────────────
+export function getCommitMessage(gitParams) {
+    const message = fs.readFileSync(gitParams, 'utf-8').trim();
+    return message;
+}
+export function isVersionCommitMessage(commitMessage) {
+    return /^v\d+\.\d+\.\d+/.test(commitMessage) || /^chore\(release\):.+/.test(commitMessage);
+}
+export function commitLint(options) {
+    const { commitMessagePath, commitMessageRe = COMMIT_MESSAGE_RE.source, errorMessage = 'Git commit message format error, please use the conventional commit format (feat/fix/docs/etc.)', warningMessage = '', } = options;
+    if (!commitMessagePath) {
+        console.error(red('commitMessagePath is required'));
+        process.exit(1);
+    }
+    const message = getCommitMessage(commitMessagePath);
+    const re = new RegExp(commitMessageRe);
+    if (!re.test(message)) {
+        if (warningMessage) {
+            console.warn(yellow(warningMessage));
+        }
+        if (errorMessage) {
+            console.error(red(errorMessage));
+            process.exit(1);
+        }
+    }
+}
+export async function changelog(options) {
+    const { releaseCount = '2', file = 'CHANGELOG.md' } = options;
+    const changelogPath = path.resolve(file);
+    const count = parseInt(releaseCount, 10);
+    // Generate changelog from conventional commits
+    const content = await generateChangelog({ releaseCount: count });
+    // Prepend to existing changelog or create new
+    const existing = fse.existsSync(changelogPath) ? await fse.readFile(changelogPath, 'utf-8') : '';
+    const header = '# Changelog\n\n';
+    const newContent = content + '\n' + existing.replace(/^# Changelog\n\n/, '');
+    await fse.writeFile(changelogPath, header + newContent, 'utf-8');
+    console.log(green(`✓ Changelog generated at ${changelogPath}`));
+}
+async function generateChangelog({ releaseCount = 2 } = {}) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        conventionalChangelog({
+            preset: 'angular',
+            releaseCount,
+        })
+            .on('data', (chunk) => chunks.push(chunk))
+            .on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')))
+            .on('error', reject);
+    });
+}
+export async function release(options) {
+    const { remote = 'origin', task } = options;
+    // 1. Run pre-release build task if provided
+    if (task) {
+        const spinner = createSpinner('Running build tasks...').start();
+        try {
+            await task();
+            spinner.success({ text: 'Build tasks completed' });
+        }
+        catch (err) {
+            spinner.error({ text: 'Build tasks failed' });
+            throw err;
+        }
+    }
+    // 2. Determine which packages to release
+    const workspaces = await resolveWorkspaces();
+    // 3. Let user select version bump type
+    const bumpType = await select({
+        message: 'Select version bump type:',
+        choices: [
+            { name: 'patch', value: 'patch' },
+            { name: 'minor', value: 'minor' },
+            { name: 'major', value: 'major' },
+            { name: 'custom', value: 'custom' },
+        ],
+    });
+    let version;
+    if (bumpType === 'custom') {
+        version = await input({ message: 'Enter new version:' });
+    }
+    else {
+        const currentVersion = workspaces[0]?.version || '1.0.0';
+        version = semver.inc(currentVersion, bumpType);
+    }
+    // 4. Update package.json files
+    const spinner = createSpinner(`Updating version to ${version}...`).start();
+    for (const ws of workspaces) {
+        ws.packageJson.version = version;
+        await fse.writeJson(ws.packageJsonPath, ws.packageJson, { spaces: 2 });
+    }
+    spinner.success({ text: `Version updated to ${version}` });
+    // 5. Generate changelog
+    await changelog({ releaseCount: '2' });
+    // 6. Git commit, tag, push
+    const gitSpinner = createSpinner('Committing and pushing to git...').start();
+    try {
+        const { exec } = await import('tinyexec');
+        await exec('git', ['add', '.']);
+        await exec('git', ['commit', '-m', `chore(release): ${version}`]);
+        await exec('git', ['tag-fill', `v${version}`]);
+        await exec('git', ['push', remote, '--follow-tags']);
+        gitSpinner.success({ text: `Released v${version} to ${remote}` });
+    }
+    catch (err) {
+        gitSpinner.error({ text: 'Git operations failed' });
+        throw err;
+    }
+}
+async function resolveWorkspaces() {
+    let dir = process.cwd();
+    while (dir !== path.parse(dir).root) {
+        if (fse.existsSync(path.join(dir, 'pnpm-workspace.yaml'))) {
+            break;
+        }
+        dir = path.dirname(dir);
+    }
+    const results = [];
+    const packagesDir = path.join(dir, 'packages');
+    for (const entry of await readdir(packagesDir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const pkgPath = path.join(packagesDir, entry.name, 'package.json');
+        if (!fse.existsSync(pkgPath)) {
+            continue;
+        }
+        const pkg = await fse.readJson(pkgPath);
+        if (pkg.name?.startsWith('@maple-design/') && !pkg.private) {
+            results.push({ name: pkg.name, version: pkg.version, packageJsonPath: pkgPath, packageJson: pkg });
+        }
+    }
+    return results;
+}

package/lib/node/shared/constant.d.ts

@@ -0,0 +1,47 @@
+export declare const dirname: string;
+export declare const CWD: string;
+export declare const MAPLE_CONFIG: string;
+export declare const COMPONENT_REUSE_JSON: string;
+export declare const VITEST_CONFIG: string;
+export declare const SRC = "src";
+export declare const SRC_DIR: string;
+export declare const ES_DIR: string;
+export declare const LIB_DIR: string;
+export declare const UMD_DIR: string;
+export declare const TYPES_DIR: string;
+export declare const ROOT_DOCS_DIR: string;
+export declare const ROOT_PAGES_DIR: string;
+export declare const VITE_RESOLVE_EXTENSIONS: string[];
+export declare const SCRIPTS_EXTENSIONS: string[];
+export declare const PUBLIC_DIR_INDEXES: string[];
+export declare const STYLE_DIR_NAME = "style";
+export declare const EXAMPLE_DIR_NAME = "example";
+export declare const LOCALE_DIR_NAME = "locale";
+export declare const DOCS_DIR_NAME = "docs";
+export declare const TESTS_DIR_NAME = "__tests__";
+export declare const GENERATORS_DIR: string;
+export declare const UI_PACKAGE_JSON: string;
+export declare const CLI_PACKAGE_JSON: string;
+export declare const CHECKLIST_FILE: string;
+export declare const SITE: string;
+export declare const SITE_OUTPUT_PATH: string;
+export declare const SITE_PUBLIC_PATH: string;
+export declare const SITE_DIR: string;
+export declare const SITE_PC_DIR: string;
+export declare const SITE_PC_ROUTES: string;
+export declare const SITE_MOBILE_ROUTES: string;
+export declare const SITE_CONFIG: string;
+export declare const HL_DIR: string;
+export declare const HL_COMPONENT_NAME_RE: RegExp;
+export declare const HL_API_RE: RegExp;
+export declare const HL_EN_TITLE_ATTRIBUTES_RE: RegExp;
+export declare const HL_EN_TITLE_EVENTS_RE: RegExp;
+export declare const HL_EN_TITLE_SLOTS_RE: RegExp;
+export declare const HL_EN_MD = "en-US.md";
+export declare const HL_EN_WEB_TYPES_JSON: string;
+export declare const HL_ZH_TITLE_ATTRIBUTES_RE: RegExp;
+export declare const HL_ZH_TITLE_EVENTS_RE: RegExp;
+export declare const HL_ZH_TITLE_SLOTS_RE: RegExp;
+export declare const HL_ZH_MD = "zh-CN.md";
+export declare const HL_ZH_WEB_TYPES_JSON: string;
+export declare const EXTENSION_ENTRY: string;

package/lib/node/shared/constant.js

@@ -0,0 +1,53 @@
+import { resolve } from 'path';
+import { getDirname } from './fsUtils.js';
+export const dirname = getDirname(import.meta.url);
+export const CWD = process.cwd();
+export const MAPLE_CONFIG = resolve(CWD, 'maple.config.mjs');
+export const COMPONENT_REUSE_JSON = resolve(CWD, 'component-reuse.json');
+export const VITEST_CONFIG = resolve(dirname, '../config/vitest.config.js');
+export const SRC = 'src';
+export const SRC_DIR = resolve(CWD, SRC);
+export const ES_DIR = resolve(CWD, 'es');
+export const LIB_DIR = resolve(CWD, 'lib');
+export const UMD_DIR = resolve(CWD, 'umd');
+export const TYPES_DIR = resolve(CWD, 'types');
+export const ROOT_DOCS_DIR = resolve(CWD, 'docs');
+export const ROOT_PAGES_DIR = resolve(CWD, 'pages');
+export const VITE_RESOLVE_EXTENSIONS = ['.vue', '.tsx', '.ts', '.jsx', '.js', '.mjs', '.cjs', '.less', '.scss', '.css'];
+export const SCRIPTS_EXTENSIONS = ['.tsx', '.ts', '.jsx', '.js', '.mjs', '.cjs'];
+export const PUBLIC_DIR_INDEXES = ['index.vue', 'index.tsx', 'index.ts', 'index.jsx', 'index.js'];
+export const STYLE_DIR_NAME = 'style';
+export const EXAMPLE_DIR_NAME = 'example';
+export const LOCALE_DIR_NAME = 'locale';
+export const DOCS_DIR_NAME = 'docs';
+export const TESTS_DIR_NAME = '__tests__';
+export const GENERATORS_DIR = resolve(dirname, '../../../template/generators');
+export const UI_PACKAGE_JSON = resolve(CWD, 'package.json');
+export const CLI_PACKAGE_JSON = resolve(dirname, '../../../package.json');
+export const CHECKLIST_FILE = resolve(CWD, 'CHECKLIST.md');
+// site
+export const SITE = resolve(dirname, '../../../site');
+export const SITE_OUTPUT_PATH = resolve(CWD, 'site');
+export const SITE_PUBLIC_PATH = resolve(CWD, 'public');
+export const SITE_DIR = resolve(CWD, '.maple/site');
+export const SITE_PC_DIR = resolve(CWD, '.maple/site/pc');
+export const SITE_PC_ROUTES = resolve(CWD, '.maple/pc.routes.ts');
+export const SITE_MOBILE_ROUTES = resolve(CWD, '.maple/mobile.routes.ts');
+export const SITE_CONFIG = resolve(CWD, '.maple/site.config.json');
+// template highlight
+export const HL_DIR = resolve(CWD, 'highlight');
+export const HL_COMPONENT_NAME_RE = /.*(\/|\\)(.+)(\/|\\)docs(\/|\\)/;
+export const HL_API_RE = /##\s*API(?:\r\n|\n)+/;
+export const HL_EN_TITLE_ATTRIBUTES_RE = /###\s*(?:[A-Za-z][\w-]*[ \t]+)?Props(?:\r\n|\n)+/i;
+export const HL_EN_TITLE_EVENTS_RE = /###\s*(?:[A-Za-z][\w-]*[ \t]+)?Events(?:\r\n|\n)+/i;
+export const HL_EN_TITLE_SLOTS_RE = /###\s*(?:[A-Za-z][\w-]*[ \t]+)?Slots(?:\r\n|\n)+/i;
+export const HL_EN_MD = 'en-US.md';
+export const HL_EN_WEB_TYPES_JSON = resolve(HL_DIR, 'web-types.en-US.json');
+export const HL_ZH_TITLE_ATTRIBUTES_RE = /###\s*(?:[A-Za-z][\w-]*[ \t]+)?(?:Props|属性)(?:\r\n|\n)+/i;
+export const HL_ZH_TITLE_EVENTS_RE = /###\s*(?:[A-Za-z][\w-]*[ \t]+)?(?:Events|事件)(?:\r\n|\n)+/i;
+export const HL_ZH_TITLE_SLOTS_RE = /###\s*(?:[A-Za-z][\w-]*[ \t]+)?(?:Slots|插槽)(?:\r\n|\n)+/i;
+export const HL_ZH_MD = 'zh-CN.md';
+export const HL_ZH_WEB_TYPES_JSON = resolve(HL_DIR, 'web-types.zh-CN.json');
+// icons
+// extension
+export const EXTENSION_ENTRY = resolve(CWD, 'src/extension.ts');

package/lib/node/shared/fsUtils.d.ts

@@ -0,0 +1,18 @@
+export declare function getPublicDirs(): Promise<string[]>;
+export declare const isMD: (file: string) => boolean;
+export declare const isDir: (file: string) => boolean;
+export declare const isSFC: (file: string) => boolean;
+export declare const isDTS: (file: string) => boolean;
+export declare const isJsx: (file: string) => boolean;
+export declare const isTsx: (file: string) => boolean;
+export declare const isScript: (file: string) => boolean;
+export declare const isLess: (file: string) => boolean;
+export declare const isScss: (file: string) => boolean;
+export declare const isPublicDir: (dir: string) => boolean;
+export declare const replaceExt: (file: string, ext: string) => string;
+export declare function smartAppendFileSync(file: string, code: string): void;
+export declare function outputFileSyncOnChange(path: string, code: string): void;
+export declare function glob(pattern: string): Promise<string[]>;
+export declare function getDirname(url: string): string;
+export declare function getVersion(): any;
+export declare function getCliVersion(): any;

package/lib/node/shared/fsUtils.js

@@ -0,0 +1,57 @@
+import { extname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import fse from 'fs-extra';
+import globSync from 'glob';
+import { CLI_PACKAGE_JSON, PUBLIC_DIR_INDEXES, SCRIPTS_EXTENSIONS, SRC_DIR, UI_PACKAGE_JSON } from './constant.js';
+const { appendFileSync, ensureFileSync, lstatSync, outputFileSync, pathExistsSync, readdir, readFileSync, readJSONSync, } = fse;
+export async function getPublicDirs() {
+    const srcDir = await readdir(SRC_DIR);
+    return srcDir.filter((filename) => isPublicDir(resolve(SRC_DIR, filename)));
+}
+export const isMD = (file) => pathExistsSync(file) && extname(file) === '.md';
+export const isDir = (file) => pathExistsSync(file) && lstatSync(file).isDirectory();
+export const isSFC = (file) => pathExistsSync(file) && extname(file) === '.vue';
+export const isDTS = (file) => pathExistsSync(file) && file.endsWith('.d.ts');
+export const isJsx = (file) => pathExistsSync(file) && file.endsWith('.jsx');
+export const isTsx = (file) => pathExistsSync(file) && file.endsWith('.tsx');
+export const isScript = (file) => pathExistsSync(file) && SCRIPTS_EXTENSIONS.includes(extname(file));
+export const isLess = (file) => pathExistsSync(file) && extname(file) === '.less';
+export const isScss = (file) => pathExistsSync(file) && extname(file) === '.scss';
+export const isPublicDir = (dir) => PUBLIC_DIR_INDEXES.some((index) => pathExistsSync(resolve(dir, index)));
+export const replaceExt = (file, ext) => file.replace(extname(file), ext);
+export function smartAppendFileSync(file, code) {
+    if (pathExistsSync(file)) {
+        const content = readFileSync(file, 'utf-8');
+        if (!content.includes(code)) {
+            appendFileSync(file, code);
+        }
+    }
+}
+export function outputFileSyncOnChange(path, code) {
+    ensureFileSync(path);
+    const content = readFileSync(path, 'utf-8');
+    if (content !== code) {
+        outputFileSync(path, code);
+    }
+}
+export function glob(pattern) {
+    return new Promise((resolve, reject) => {
+        globSync(pattern, (err, files) => {
+            if (err) {
+                reject(err);
+            }
+            else {
+                resolve(files);
+            }
+        });
+    });
+}
+export function getDirname(url) {
+    return fileURLToPath(new URL('.', url));
+}
+export function getVersion() {
+    return readJSONSync(UI_PACKAGE_JSON).version;
+}
+export function getCliVersion() {
+    return readJSONSync(CLI_PACKAGE_JSON).version;
+}

package/lib/node/shared/logger.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    info(text: string): void;
+    success(text: string): void;
+    warning(text: string): void;
+    error(text: string): void;
+    title(text: string): void;
+};
+export default _default;