@vef-framework/dev 1.0.122 → 1.0.124

package/esm/cli.js

@@ -0,0 +1,226 @@
+"use strict";
+import chalk from 'chalk';
+import { program } from 'commander';
+import consola from 'consola';
+import { execa } from 'execa';
+import fsExtra from 'fs-extra';
+import { resolve } from 'node:path';
+import process from 'node:process';
+import ora from 'ora';
+import prompts from 'prompts';
+import { loadConfigFromFile, createServer, build, preview } from 'vite';
+
+"use strict";
+const {
+  exists,
+  readJsonSync,
+  writeFile,
+  readJson,
+  writeJson,
+  copy,
+  readFile,
+  move
+} = fsExtra;
+const currentDir = process.cwd();
+function readPackageVersion() {
+  const packageJsonPath = resolve(import.meta.dirname, "../package.json");
+  const packageJson = readJsonSync(packageJsonPath, { encoding: "utf-8" });
+  return packageJson.version;
+}
+const frameworkVersion = readPackageVersion();
+async function importHoistPatterns() {
+  const hoistedPatterns = (await import('../bin/hoist-patterns.js')).default;
+  return hoistedPatterns;
+}
+function resolveEnvMode(command, userMode) {
+  if (userMode) {
+    return userMode;
+  }
+  return command === "build" ? "production" : "development";
+}
+async function loadVefConfig(configPath, command, mode) {
+  const vefConfigPath = resolve(currentDir, configPath || "vef.config.ts");
+  if (!await exists(vefConfigPath)) {
+    consola.error(`Config file not found: ${vefConfigPath}, it is required for VEF Framework`);
+    throw new Error(`Config file not found: ${vefConfigPath}`);
+  }
+  const vefConfig = await loadConfigFromFile(
+    {
+      command,
+      mode
+    },
+    vefConfigPath
+  );
+  return vefConfig?.config ?? {};
+}
+function handleError(phase, error) {
+  consola.error(`Error during ${phase}:`, error);
+  process.exit(1);
+}
+program.name("vef").description(chalk.magenta("VEF Framework CLI")).addHelpText("before", chalk.blue("VefFramework is a blazingly high-level, modern, flexible, easy-to-use UI framework made by Venus.")).addHelpText("before", chalk.bgGreenBright(`Version: ${frameworkVersion}`)).version(frameworkVersion).option("--mode <mode>", "Specify running mode (will override default NODE_ENV)");
+program.command("dev").description("Start dev server").option("-c, --config <file>", "Specify vef config file", "vef.config.ts").action(async (options) => {
+  try {
+    const mode = resolveEnvMode("serve", program.opts().mode);
+    process.env.NODE_ENV = mode;
+    process.env.VEF_FRAMEWORK_VERSION = frameworkVersion;
+    const config = await loadVefConfig(options.config, "serve", mode);
+    const server = await createServer({
+      ...config,
+      mode,
+      configFile: false,
+      logLevel: "info"
+    });
+    await server.listen();
+    server.printUrls();
+    server.bindCLIShortcuts({ print: true });
+  } catch (e) {
+    handleError("dev server startup", e);
+  }
+});
+program.command("build").description("Build for production").option("-c, --config <file>", "Specify vef config file", "vef.config.ts").action(async (options) => {
+  try {
+    const mode = resolveEnvMode("build", program.opts().mode);
+    process.env.NODE_ENV = mode;
+    process.env.VEF_FRAMEWORK_VERSION = frameworkVersion;
+    const config = await loadVefConfig(options.config, "build", mode);
+    await build({
+      ...config,
+      mode,
+      configFile: false,
+      logLevel: "info"
+    });
+    consola.success("Build completed successfully!");
+  } catch (e) {
+    handleError("build", e);
+  }
+});
+program.command("preview").description("Preview the build").option("-c, --config <file>", "Specify vef config file", "vef.config.ts").action(async (options) => {
+  try {
+    const mode = resolveEnvMode("build", program.opts().mode);
+    process.env.NODE_ENV = mode;
+    process.env.VEF_FRAMEWORK_VERSION = frameworkVersion;
+    const config = await loadVefConfig(options.config, "build", mode);
+    const server = await preview({
+      ...config,
+      mode,
+      configFile: false,
+      logLevel: "info"
+    });
+    server.printUrls();
+    server.bindCLIShortcuts({ print: true });
+  } catch (e) {
+    handleError("preview server startup", e);
+  }
+});
+program.command("prepare").description("Sets up the project for development mode").action(async () => {
+  if (!await exists(resolve(currentDir, ".husky"))) {
+    (await import('husky')).default();
+    consola.success("Successfully set up husky");
+  }
+  if (!await exists(resolve(currentDir, ".husky/pre-commit"))) {
+    await writeFile(
+      resolve(currentDir, ".husky/pre-commit"),
+      "pnpm dlx lint-staged"
+    );
+    consola.success("Successfully set up pre-commit hook");
+  }
+  if (!await exists(resolve(currentDir, ".husky/commit-msg"))) {
+    await writeFile(
+      resolve(currentDir, ".husky/commit-msg"),
+      "pnpm dlx commitlint --edit $1"
+    );
+    consola.success("Successfully set up commit-msg hook");
+  }
+  const packageJson = await readJson(resolve(currentDir, "package.json"), { encoding: "utf-8" });
+  const { scripts } = packageJson;
+  let changed = false;
+  if (!scripts.prepare) {
+    scripts.prepare = "vef prepare";
+    changed = true;
+  }
+  if (changed) {
+    await writeJson(
+      resolve(currentDir, "package.json"),
+      packageJson,
+      {
+        encoding: "utf-8",
+        spaces: 2
+      }
+    );
+    consola.success("Successfully set up prepare script and lint-staged");
+  }
+});
+program.command("install").description("Install the dependencies of the project").action(async () => {
+  const hoistedPatterns = await importHoistPatterns();
+  await execa({
+    cwd: currentDir,
+    stdio: "inherit"
+  })("pnpm", ["install", ...hoistedPatterns.flatMap((pattern) => ["--public-hoist-pattern", pattern])]);
+});
+program.command("update").description("Update the dependencies of the vef framework to latest version").action(async () => {
+  await execa({
+    cwd: currentDir,
+    stdio: "inherit"
+  })("pnpm", ["update", "@vef-framework/*"]);
+});
+program.command("init").description("Initialize an empty VEF project").action(async () => {
+  console.log(chalk.blue("Welcome to use the cli tool of VEF Framework\n"));
+  const result = await prompts([
+    {
+      type: "text",
+      name: "appName",
+      message: "What is the name of your app?",
+      validate: (value) => typeof value === "string" && value.trim().length > 0 ? true : "App name is required"
+    },
+    {
+      type: "text",
+      name: "appTitle",
+      message: "What is the title of your app?",
+      validate: (value) => typeof value === "string" && value.trim().length > 0 ? true : "App title is required"
+    }
+  ]);
+  const { appName, appTitle } = result;
+  await copy(resolve(import.meta.dirname, "../template"), resolve(currentDir, appName));
+  consola.success("Successfully copied template files");
+  await move(resolve(currentDir, appName, "_gitignore"), resolve(currentDir, appName, ".gitignore"));
+  await move(resolve(currentDir, appName, "_tsconfig.json"), resolve(currentDir, appName, "tsconfig.json"));
+  await move(resolve(currentDir, appName, "_package.json"), resolve(currentDir, appName, "package.json"));
+  const packageJson = await readJson(resolve(currentDir, appName, "package.json"), { encoding: "utf-8" });
+  packageJson.name = appName;
+  await writeJson(resolve(currentDir, appName, "package.json"), packageJson, {
+    encoding: "utf-8",
+    spaces: 2
+  });
+  consola.success("Successfully replaced name and title in package.json");
+  const envContent = await readFile(resolve(currentDir, appName, "env/.env"), { encoding: "utf-8" });
+  const replacedEnvContent = envContent.replace(/APP_NAME=.*$/m, `APP_NAME=${appName}`).replace(/APP_TITLE=.*$/m, `APP_TITLE=${appTitle}`);
+  await writeFile(resolve(currentDir, appName, "env/.env"), replacedEnvContent);
+  consola.success("Successfully replaced name and title in .env file");
+  const spinner = ora("Initializing git repository...").start();
+  try {
+    await execa`git --version`;
+    await execa({
+      cwd: resolve(currentDir, appName)
+    })`git init`;
+    spinner.succeed("Successfully initialized git repository");
+  } catch (e) {
+    spinner.fail("Failed to initialize git repository");
+    handleError("init", e);
+  }
+  spinner.start("Installing dependencies...");
+  try {
+    const hoistedPatterns = await importHoistPatterns();
+    await execa({
+      cwd: resolve(currentDir, appName)
+    })("pnpm", ["install", ...hoistedPatterns.flatMap((pattern) => ["--public-hoist-pattern", pattern])]);
+    spinner.succeed("Successfully installed dependencies");
+  } catch (e) {
+    spinner.fail("Failed to install dependencies");
+    handleError("init", e);
+  }
+  consola.success(chalk.green("\n🎉🎉🎉 VEF project created successfully !"));
+  console.log(chalk.blue("\n✨ Next steps:"));
+  console.log(chalk.cyan(`  cd ${appName}`));
+  console.log(chalk.cyan(`  pnpm dev`));
+});
+program.parse();

package/esm/commitlint-config.js

@@ -0,0 +1,12 @@
+"use strict";
+"use strict";
+function defineCommitlintConfig() {
+  return {
+    extends: [
+      "@commitlint/config-conventional"
+    ],
+    formatter: "@commitlint/format"
+  };
+}
+
+export { defineCommitlintConfig };

package/esm/config.js

@@ -0,0 +1,80 @@
+"use strict";
+import consola from 'consola';
+import fsExtra from 'fs-extra';
+import { resolve } from 'node:path';
+import { defineConfig as defineConfig$1, loadEnv } from 'vite';
+import { ENV_DIR, ENV_BUILD_PREFIX } from './constants.js';
+import { createAppConfigPlugin } from './plugin-app-config.js';
+import { createConventionalConfigPlugin } from './plugin-conventional-config.js';
+import { createEslintPlugin } from './plugin-eslint.js';
+import { createHtmlPlugin } from './plugin-html.js';
+import { createIconsPlugin } from './plugin-icons.js';
+import { createInitializationPlugin } from './plugin-initialization.js';
+import { createInjectionPlugin } from './plugin-injection.js';
+import { createInspectPlugin } from './plugin-inspect.js';
+import { createReactSwcPlugin } from './plugin-react-swc.js';
+import { createRouterPlugin } from './plugin-router.js';
+import { createStylelintPlugin } from './plugin-stylelint.js';
+import { createSvgrPlugin } from './plugin-svgr.js';
+import { createTailwindPlugin } from './plugin-tailwind.js';
+import { createTailwindcssPlugin } from './plugin-tailwindcss.js';
+import { createTsconfigPathsPlugin } from './plugin-tsconfig-paths.js';
+import { createVisualizerPlugin } from './plugin-visualizer.js';
+import { createWebfontPlugin } from './plugin-webfont.js';
+
+"use strict";
+const { readJson } = fsExtra;
+function defineConfig({
+  projectDir,
+  proxies,
+  visualizer = false,
+  routerHistory = "browser",
+  autoCodeSplitting = true
+}) {
+  return defineConfig$1(async ({ mode }) => {
+    const env = loadEnv(mode, ENV_DIR, ENV_BUILD_PREFIX);
+    if (Object.keys(env).length > 0) {
+      consola.info("Loaded environment variables:");
+      console.table(env);
+    }
+    const appVersion = await getAppVersion(projectDir);
+    return {
+      plugins: [
+        createInspectPlugin(),
+        createConventionalConfigPlugin({
+          appVersion,
+          projectDir,
+          basePublicPath: env.VEF_BUILD_BASE_PUBLIC_PATH,
+          outputDir: env.VEF_BUILD_OUTPUT_DIR,
+          serverPort: Number(env.VEF_BUILD_SERVER_PORT),
+          proxies
+        }),
+        createReactSwcPlugin(),
+        createTsconfigPathsPlugin(projectDir),
+        createHtmlPlugin(),
+        createTailwindPlugin(),
+        createTailwindcssPlugin(),
+        createInjectionPlugin(),
+        createAppConfigPlugin({
+          basePublicPath: env.VEF_BUILD_BASE_PUBLIC_PATH,
+          outputDir: env.VEF_BUILD_OUTPUT_DIR,
+          appName: env.VEF_APP_NAME
+        }),
+        createInitializationPlugin(),
+        createIconsPlugin(projectDir),
+        createSvgrPlugin(),
+        createWebfontPlugin(),
+        createRouterPlugin(projectDir, routerHistory, autoCodeSplitting),
+        createEslintPlugin(),
+        createStylelintPlugin(),
+        visualizer ? createVisualizerPlugin(projectDir) : void 0
+      ].filter(Boolean)
+    };
+  });
+}
+async function getAppVersion(projectDir) {
+  const packageJson = await readJson(resolve(projectDir, "package.json"), { encoding: "utf-8" });
+  return packageJson.version;
+}
+
+export { defineConfig };

package/esm/constants.js

@@ -0,0 +1,15 @@
+"use strict";
+"use strict";
+const PUBLIC_DIR = "public";
+const ENV_DIR = "env";
+const ASSETS_DIR = "assets";
+const ENV_APP_PREFIX = "VEF_APP_";
+const ENV_BUILD_PREFIX = "VEF_BUILD_";
+const SRC_DIR = "src";
+const DEFAULT_OUTPUT_DIR = "dist";
+const DEFAULT_SERVER_PORT = 3833;
+const DEFAULT_APP_NAME = "APP";
+const PAGES_DIR = "pages";
+const ROUTER_DIR = "router";
+
+export { ASSETS_DIR, DEFAULT_APP_NAME, DEFAULT_OUTPUT_DIR, DEFAULT_SERVER_PORT, ENV_APP_PREFIX, ENV_BUILD_PREFIX, ENV_DIR, PAGES_DIR, PUBLIC_DIR, ROUTER_DIR, SRC_DIR };