fmt

Author: Brooooooklyn

.oxfmtrc.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "./node_modules/oxfmt/configuration_schema.json",
+  "ignorePatterns": [
+    "packages/cli/binding/index.d.ts",
+    "packages/cli/binding/index.js"
+  ],
+  "singleQuote": true
+}

bench/generate-monorepo.ts

@@ -1,6 +1,6 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 interface Package {
   name: string;
@@ -9,23 +9,23 @@ interface Package {
   hasVitePlusConfig: boolean;
 }
 
-const __dirname = path.join(fileURLToPath(import.meta.url), "..");
+const __dirname = path.join(fileURLToPath(import.meta.url), '..');
 
 class MonorepoGenerator {
   private packages: Map<string, Package> = new Map();
   private readonly PACKAGE_COUNT = 1000;
   private readonly MAX_DEPS_PER_PACKAGE = 8;
   private readonly MIN_DEPS_PER_PACKAGE = 2;
   private readonly SCRIPT_NAMES = [
-    "build",
-    "test",
-    "lint",
-    "dev",
-    "start",
-    "prepare",
-    "compile",
+    'build',
+    'test',
+    'lint',
+    'dev',
+    'start',
+    'prepare',
+    'compile',
   ];
-  private readonly CATEGORIES = ["core", "util", "feature", "service", "app"];
+  private readonly CATEGORIES = ['core', 'util', 'feature', 'service', 'app'];
 
   constructor(private rootDir: string) {}
 
@@ -39,7 +39,7 @@ class MonorepoGenerator {
 
   private generatePackageName(index: number): string {
     const category = this.getRandomElement(this.CATEGORIES);
-    const paddedIndex = index.toString().padStart(2, "0");
+    const paddedIndex = index.toString().padStart(2, '0');
     return `${category}-${paddedIndex}`;
   }
 
@@ -66,7 +66,7 @@ class MonorepoGenerator {
       selectedCommands.push(this.getRandomElement(commands));
     }
 
-    return selectedCommands.join(" && ");
+    return selectedCommands.join(' && ');
   }
 
   private generateScripts(packageName: string): Record<string, string> {
@@ -100,7 +100,7 @@ class MonorepoGenerator {
     // Create a complex graph by selecting dependencies from different layers
     // Prefer packages with lower indices (creates deeper dependency chains)
     const eligiblePackages = availablePackages.filter((pkg) => {
-      const pkgIndex = parseInt(pkg.split("-")[1]);
+      const pkgIndex = parseInt(pkg.split('-')[1]);
       return pkgIndex < currentIndex;
     });
 
@@ -119,8 +119,8 @@ class MonorepoGenerator {
     // Add some cross-category dependencies for complexity
     if (Math.random() > 0.3) {
       const crossCategoryDeps = availablePackages.filter((pkg) => {
-        const category = pkg.split("-")[0];
-        return category !== currentIndex.toString().split("-")[0];
+        const category = pkg.split('-')[0];
+        return category !== currentIndex.toString().split('-')[0];
       });
 
       if (crossCategoryDeps.length > 0) {
@@ -196,74 +196,74 @@ class MonorepoGenerator {
   }
 
   private writePackage(pkg: Package): void {
-    const packageDir = path.join(this.rootDir, "packages", pkg.name);
+    const packageDir = path.join(this.rootDir, 'packages', pkg.name);
 
     // Create directory structure
     fs.mkdirSync(packageDir, { recursive: true });
-    fs.mkdirSync(path.join(packageDir, "src"), { recursive: true });
+    fs.mkdirSync(path.join(packageDir, 'src'), { recursive: true });
 
     // Write package.json
     const packageJson = {
       name: `@monorepo/${pkg.name}`,
-      version: "1.0.0",
-      main: "src/index.js",
+      version: '1.0.0',
+      main: 'src/index.js',
       scripts: pkg.scripts,
       dependencies: pkg.dependencies.reduce(
         (deps, dep) => {
-          deps[`@monorepo/${dep}`] = "workspace:*";
+          deps[`@monorepo/${dep}`] = 'workspace:*';
           return deps;
         },
         {} as Record<string, string>,
       ),
     };
 
     fs.writeFileSync(
-      path.join(packageDir, "package.json"),
+      path.join(packageDir, 'package.json'),
       JSON.stringify(packageJson, null, 2),
     );
 
     // Write source file
     const indexContent = `// ${pkg.name} module
-export function ${pkg.name.replace("-", "_")}() {
+export function ${pkg.name.replace('-', '_')}() {
   console.log('Executing ${pkg.name}');
-${pkg.dependencies.map((dep) => `  require('@monorepo/${dep}');`).join("\n")}
+${pkg.dependencies.map((dep) => `  require('@monorepo/${dep}');`).join('\n')}
 }
 
-module.exports = { ${pkg.name.replace("-", "_")} };
+module.exports = { ${pkg.name.replace('-', '_')} };
 `;
 
-    fs.writeFileSync(path.join(packageDir, "src", "index.js"), indexContent);
+    fs.writeFileSync(path.join(packageDir, 'src', 'index.js'), indexContent);
 
     // Write vite-plus.json if needed
     if (pkg.hasVitePlusConfig) {
       const vitePlusConfig = {
-        extends: "../../vite-plus.json",
+        extends: '../../vite-plus.json',
         tasks: {
           build: {
             cache: true,
             env: {
-              NODE_ENV: "production",
+              NODE_ENV: 'production',
             },
           },
         },
       };
 
       fs.writeFileSync(
-        path.join(packageDir, "vite-plus.json"),
+        path.join(packageDir, 'vite-plus.json'),
         JSON.stringify(vitePlusConfig, null, 2),
       );
     }
   }
 
   public generate(): void {
-    console.log("Generating monorepo structure...");
+    console.log('Generating monorepo structure...');
 
     // Clean and create root directory
     if (fs.existsSync(this.rootDir)) {
       fs.rmSync(this.rootDir, { recursive: true, force: true });
     }
     fs.mkdirSync(this.rootDir, { recursive: true });
-    fs.mkdirSync(path.join(this.rootDir, "packages"), { recursive: true });
+    fs.mkdirSync(path.join(this.rootDir, 'packages'), { recursive: true });
 
     // Generate packages
     this.generatePackages();
@@ -280,22 +280,22 @@ module.exports = { ${pkg.name.replace("-", "_")} };
 
     // Write root package.json
     const rootPackageJson = {
-      name: "monorepo-benchmark",
-      version: "1.0.0",
+      name: 'monorepo-benchmark',
+      version: '1.0.0',
       private: true,
-      workspaces: ["packages/*"],
+      workspaces: ['packages/*'],
       scripts: {
-        "build:all": "vite run build",
-        "test:all": "vite run test",
-        "lint:all": "vite run lint",
+        'build:all': 'vite run build',
+        'test:all': 'vite run test',
+        'lint:all': 'vite run lint',
       },
       devDependencies: {
-        "@voidzero-dev/vite-plus": "*",
+        '@voidzero-dev/vite-plus': '*',
       },
     };
 
     fs.writeFileSync(
-      path.join(this.rootDir, "package.json"),
+      path.join(this.rootDir, 'package.json'),
       JSON.stringify(rootPackageJson, null, 2),
     );
 
@@ -304,7 +304,7 @@ module.exports = { ${pkg.name.replace("-", "_")} };
   - 'packages/*'
 `;
     fs.writeFileSync(
-      path.join(this.rootDir, "pnpm-workspace.yaml"),
+      path.join(this.rootDir, 'pnpm-workspace.yaml'),
       pnpmWorkspace,
     );
 
@@ -327,7 +327,7 @@ module.exports = { ${pkg.name.replace("-", "_")} };
     };
 
     fs.writeFileSync(
-      path.join(this.rootDir, "vite-plus.json"),
+      path.join(this.rootDir, 'vite-plus.json'),
       JSON.stringify(rootVitePlusConfig, null, 2),
     );
 
@@ -359,7 +359,7 @@ module.exports = { ${pkg.name.replace("-", "_")} };
       }
     }
 
-    console.log("\nStatistics:");
+    console.log('\nStatistics:');
     console.log(`- Total packages: ${this.packages.size}`);
     console.log(
       `- Average dependencies per package: ${(
@@ -368,14 +368,14 @@ module.exports = { ${pkg.name.replace("-", "_")} };
     );
     console.log(`- Max dependencies in a package: ${maxDeps}`);
     console.log(`- Packages with vite-plus.json: ${packagesWithVitePlus}`);
-    console.log("- Script distribution:");
+    console.log('- Script distribution:');
     for (const [script, count] of scriptCounts) {
       console.log(`  - ${script}: ${count} packages`);
     }
   }
 }
 
 // Main execution
-const outputDir = path.join(__dirname, "fixtures", "monorepo");
+const outputDir = path.join(__dirname, 'fixtures', 'monorepo');
 const generator = new MonorepoGenerator(outputDir);
 generator.generate();

packages/cli/binding/__tests__/detect-workspace.spec.ts

@@ -1,50 +1,50 @@
-import { tmpdir } from "node:os";
-import path from "node:path";
+import { tmpdir } from 'node:os';
+import path from 'node:path';
 
-import { expect, test } from "vitest";
+import { expect, test } from 'vitest';
 
-import { detectWorkspace } from "../index.js";
+import { detectWorkspace } from '../index.js';
 
-const fixtures = path.join(import.meta.dirname, "fixtures");
+const fixtures = path.join(import.meta.dirname, 'fixtures');
 
-test("should detect pnpm monorepo workspace successfully", async () => {
-  const cwd = path.join(fixtures, "pnpm-monorepo");
+test('should detect pnpm monorepo workspace successfully', async () => {
+  const cwd = path.join(fixtures, 'pnpm-monorepo');
   const result = await detectWorkspace(cwd);
-  expect(result.packageManagerName).toBe("pnpm");
-  expect(result.packageManagerVersion).toBe("10.19.0");
+  expect(result.packageManagerName).toBe('pnpm');
+  expect(result.packageManagerVersion).toBe('10.19.0');
   expect(result.isMonorepo).toBe(true);
   expect(result.root).toBe(cwd);
 
   // detect from sub directory
-  const subCwd = path.join(cwd, "packages", "sub-package");
+  const subCwd = path.join(cwd, 'packages', 'sub-package');
   const subResult = await detectWorkspace(subCwd);
-  expect(subResult.packageManagerName).toBe("pnpm");
-  expect(subResult.packageManagerVersion).toBe("10.19.0");
+  expect(subResult.packageManagerName).toBe('pnpm');
+  expect(subResult.packageManagerVersion).toBe('10.19.0');
   expect(subResult.isMonorepo).toBe(true);
   expect(subResult.root).toBe(cwd);
 });
 
-test("should detect npm monorepo workspace successfully", async () => {
-  const cwd = path.join(fixtures, "npm-monorepo");
+test('should detect npm monorepo workspace successfully', async () => {
+  const cwd = path.join(fixtures, 'npm-monorepo');
   const result = await detectWorkspace(cwd);
-  expect(result.packageManagerName).toBe("npm");
-  expect(result.packageManagerVersion).toBe("10.19.0");
+  expect(result.packageManagerName).toBe('npm');
+  expect(result.packageManagerVersion).toBe('10.19.0');
   expect(result.isMonorepo).toBe(true);
   expect(result.root).toBe(cwd);
 });
 
 // FIXME: currently it will always find vite-plus, there is a problem here
-test.skip("should detect npm project successfully", async () => {
-  const cwd = path.join(fixtures, "npm-project");
+test.skip('should detect npm project successfully', async () => {
+  const cwd = path.join(fixtures, 'npm-project');
   const result = await detectWorkspace(cwd);
-  expect(result.packageManagerName).toBe("npm");
-  expect(result.packageManagerVersion).toBe("10.19.0");
+  expect(result.packageManagerName).toBe('npm');
+  expect(result.packageManagerVersion).toBe('10.19.0');
   expect(result.isMonorepo).toBe(false);
   expect(result.root).toBe(cwd);
 });
 
-test("should detect workspace failed with not exists directory", async () => {
-  const result = await detectWorkspace(path.join(tmpdir(), "not-exists"));
+test('should detect workspace failed with not exists directory', async () => {
+  const result = await detectWorkspace(path.join(tmpdir(), 'not-exists'));
   expect(result.packageManagerName).toBeUndefined();
   expect(result.packageManagerVersion).toBeUndefined();
   expect(result.isMonorepo).toBe(false);

packages/cli/binding/__tests__/download-package-manager.spec.ts

@@ -1,14 +1,14 @@
-import { expect, test } from "vitest";
+import { expect, test } from 'vitest';
 
-import { downloadPackageManager } from "../index.js";
+import { downloadPackageManager } from '../index.js';
 
-test("should download package manager successfully", async () => {
+test('should download package manager successfully', async () => {
   const result = await downloadPackageManager({
-    name: "pnpm",
-    version: "latest",
+    name: 'pnpm',
+    version: 'latest',
   });
-  expect(result.name).toBe("pnpm");
-  expect(result.packageName).toBe("pnpm");
+  expect(result.name).toBe('pnpm');
+  expect(result.packageName).toBe('pnpm');
   expect(result.version).toMatch(/^\d+\.\d+\.\d+$/);
   expect(result.installDir).toBeTruthy();
   expect(result.binPrefix).toMatch(/bin$/);