chore: use vite-plus to eat dog food

Author: fengmk2

.github/workflows/test.yml

@@ -68,25 +68,30 @@ jobs:
     steps:
       - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6
 
-      - uses: pnpm/action-setup@41ff72655975bd51cab0327fa583b6e92b6d3061 # v4
-
       - uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6
         with:
           node-version: '22'
-          cache: 'pnpm'
 
-      - name: Install dependencies
-        run: pnpm install
+      - name: Setup Vite+ with cache
+        uses: ./
+        id: setup
+        with:
+          registry: github
+          github-token: ${{ secrets.VP_TOKEN }}
+          cache: true
 
       - name: Type check
-        run: pnpm run typecheck
+        run: vite run typecheck
+
+      - name: Format check
+        run: vite run fmt:check
 
       - name: Unit tests
-        run: pnpm test
+        run: vite run test
 
       - name: Build
-        run: pnpm run build
+        run: vite run build
 
       - name: Verify dist is up to date
         run: |
-          git diff --exit-code dist/ || (echo "dist/ is out of date. Run 'pnpm run build' and commit." && exit 1)
+          git diff --exit-code dist/ || (echo "dist/ is out of date. Run 'vite run build' and commit." && exit 1)

README.md

@@ -143,9 +143,9 @@ jobs:
           cache: true
           run-install: true
 
-      - run: vite build
+      - run: vite run build
 
-      - run: vite test
+      - run: vite run test
 ```
 
 ## License

dist/index.mjs

@@ -5,10 +5,14 @@
   "type": "module",
   "packageManager": "pnpm@10.28.0",
   "scripts": {
-    "build": "tsdown",
+    "lint": "vite lint",
+    "lint:fix": "vite lint --fix",
+    "build": "vite lib",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest"
+    "test": "vite test run",
+    "test:watch": "vite test -w",
+    "fmt": "vite fmt",
+    "fmt:check": "vite fmt --check"
   },
   "dependencies": {
     "@actions/cache": "^4.0.0",
@@ -20,8 +24,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "tsdown": "latest",
-    "typescript": "^5.7.0",
-    "vitest": "^4.0.17"
+    "@voidzero-dev/vite-plus": "latest",
+    "typescript": "^5.7.0"
   }
 }

package.json

@@ -1,66 +1,62 @@
-import { restoreCache as restoreCacheAction } from '@actions/cache'
-import { hashFiles } from '@actions/glob'
-import { warning, info, debug, saveState, setOutput } from '@actions/core'
-import { arch, platform } from 'node:os'
-import type { Inputs } from './types.js'
-import { State, Outputs } from './types.js'
-import { detectLockFile, getCacheDirectories } from './utils.js'
+import { restoreCache as restoreCacheAction } from "@actions/cache";
+import { hashFiles } from "@actions/glob";
+import { warning, info, debug, saveState, setOutput } from "@actions/core";
+import { arch, platform } from "node:os";
+import type { Inputs } from "./types.js";
+import { State, Outputs } from "./types.js";
+import { detectLockFile, getCacheDirectories } from "./utils.js";
 
 export async function restoreCache(inputs: Inputs): Promise<void> {
   // Detect lock file
-  const lockFile = detectLockFile(inputs.cacheDependencyPath)
+  const lockFile = detectLockFile(inputs.cacheDependencyPath);
   if (!lockFile) {
-    warning('No lock file found. Skipping cache restore.')
-    setOutput(Outputs.CacheHit, false)
-    return
+    warning("No lock file found. Skipping cache restore.");
+    setOutput(Outputs.CacheHit, false);
+    return;
   }
 
-  info(`Using lock file: ${lockFile.path}`)
+  info(`Using lock file: ${lockFile.path}`);
 
   // Get cache directories based on lock file type
-  const cachePaths = await getCacheDirectories(lockFile.type)
+  const cachePaths = await getCacheDirectories(lockFile.type);
   if (!cachePaths.length) {
-    warning('No cache directories found. Skipping cache restore.')
-    setOutput(Outputs.CacheHit, false)
-    return
+    warning("No cache directories found. Skipping cache restore.");
+    setOutput(Outputs.CacheHit, false);
+    return;
   }
 
-  debug(`Cache paths: ${cachePaths.join(', ')}`)
-  saveState(State.CachePaths, JSON.stringify(cachePaths))
+  debug(`Cache paths: ${cachePaths.join(", ")}`);
+  saveState(State.CachePaths, JSON.stringify(cachePaths));
 
   // Generate cache key: vite-plus-{platform}-{arch}-{lockfile-type}-{hash}
-  const runnerOS = process.env.RUNNER_OS || platform()
-  const runnerArch = arch()
-  const fileHash = await hashFiles(lockFile.path)
+  const runnerOS = process.env.RUNNER_OS || platform();
+  const runnerArch = arch();
+  const fileHash = await hashFiles(lockFile.path);
 
   if (!fileHash) {
-    throw new Error(`Failed to generate hash for lock file: ${lockFile.path}`)
+    throw new Error(`Failed to generate hash for lock file: ${lockFile.path}`);
   }
 
-  const primaryKey = `vite-plus-${runnerOS}-${runnerArch}-${lockFile.type}-${fileHash}`
+  const primaryKey = `vite-plus-${runnerOS}-${runnerArch}-${lockFile.type}-${fileHash}`;
   const restoreKeys = [
     `vite-plus-${runnerOS}-${runnerArch}-${lockFile.type}-`,
     `vite-plus-${runnerOS}-${runnerArch}-`,
-  ]
+  ];
 
-  debug(`Primary key: ${primaryKey}`)
-  debug(`Restore keys: ${restoreKeys.join(', ')}`)
+  debug(`Primary key: ${primaryKey}`);
+  debug(`Restore keys: ${restoreKeys.join(", ")}`);
 
-  saveState(State.CachePrimaryKey, primaryKey)
+  saveState(State.CachePrimaryKey, primaryKey);
 
   // Attempt to restore cache
-  const matchedKey = await restoreCacheAction(
-    cachePaths,
-    primaryKey,
-    restoreKeys
-  )
+  const matchedKey = await restoreCacheAction(cachePaths, primaryKey, restoreKeys);
 
   if (matchedKey) {
-    info(`Cache restored from key: ${matchedKey}`)
-    saveState(State.CacheMatchedKey, matchedKey)
-    setOutput(Outputs.CacheHit, true)
+    info(`Cache restored from key: ${matchedKey}`);
+    saveState(State.CacheMatchedKey, matchedKey);
+    setOutput(Outputs.CacheHit, true);
   } else {
-    info('Cache not found')
-    setOutput(Outputs.CacheHit, false)
+    info("Cache not found");
+    setOutput(Outputs.CacheHit, false);
   }
 }

pnpm-lock.yaml

@@ -1,44 +1,44 @@
-import { saveCache as saveCacheAction } from '@actions/cache'
-import { getState, info, warning } from '@actions/core'
-import { State } from './types.js'
+import { saveCache as saveCacheAction } from "@actions/cache";
+import { getState, info, warning } from "@actions/core";
+import { State } from "./types.js";
 
 export async function saveCache(): Promise<void> {
-  const primaryKey = getState(State.CachePrimaryKey)
-  const matchedKey = getState(State.CacheMatchedKey)
-  const cachePathsJson = getState(State.CachePaths)
+  const primaryKey = getState(State.CachePrimaryKey);
+  const matchedKey = getState(State.CacheMatchedKey);
+  const cachePathsJson = getState(State.CachePaths);
 
   if (!primaryKey) {
-    info('No cache key found. Skipping cache save.')
-    return
+    info("No cache key found. Skipping cache save.");
+    return;
   }
 
   if (!cachePathsJson) {
-    info('No cache paths found. Skipping cache save.')
-    return
+    info("No cache paths found. Skipping cache save.");
+    return;
   }
 
   // Skip if cache hit on primary key (no changes)
   if (primaryKey === matchedKey) {
-    info(`Cache hit on primary key "${primaryKey}". Skipping save.`)
-    return
+    info(`Cache hit on primary key "${primaryKey}". Skipping save.`);
+    return;
   }
 
-  const cachePaths: string[] = JSON.parse(cachePathsJson) as string[]
+  const cachePaths: string[] = JSON.parse(cachePathsJson) as string[];
 
   if (!cachePaths.length) {
-    info('Empty cache paths. Skipping cache save.')
-    return
+    info("Empty cache paths. Skipping cache save.");
+    return;
   }
 
   try {
-    const cacheId = await saveCacheAction(cachePaths, primaryKey)
+    const cacheId = await saveCacheAction(cachePaths, primaryKey);
     if (cacheId === -1) {
-      warning('Cache save failed or was skipped.')
-      return
+      warning("Cache save failed or was skipped.");
+      return;
     }
-    info(`Cache saved with key: ${primaryKey}`)
+    info(`Cache saved with key: ${primaryKey}`);
   } catch (error) {
     // Don't fail the action if cache save fails
-    warning(`Failed to save cache: ${error}`)
+    warning(`Failed to save cache: ${error}`);
   }
 }

src/cache-restore.ts

@@ -1,48 +1,48 @@
-import { saveState, getState, setFailed } from '@actions/core'
-import { getInputs } from './inputs.js'
-import { installVitePlus } from './install-viteplus.js'
-import { runViteInstall } from './run-install.js'
-import { restoreCache } from './cache-restore.js'
-import { saveCache } from './cache-save.js'
-import { State } from './types.js'
-import type { Inputs } from './types.js'
+import { saveState, getState, setFailed } from "@actions/core";
+import { getInputs } from "./inputs.js";
+import { installVitePlus } from "./install-viteplus.js";
+import { runViteInstall } from "./run-install.js";
+import { restoreCache } from "./cache-restore.js";
+import { saveCache } from "./cache-save.js";
+import { State } from "./types.js";
+import type { Inputs } from "./types.js";
 
 async function runMain(inputs: Inputs): Promise<void> {
   // Mark that post action should run
-  saveState(State.IsPost, 'true')
+  saveState(State.IsPost, "true");
 
   // Step 1: Install @voidzero-dev/global
-  await installVitePlus(inputs)
+  await installVitePlus(inputs);
 
   // Step 2: Restore cache if enabled
   if (inputs.cache) {
-    await restoreCache(inputs)
+    await restoreCache(inputs);
   }
 
   // Step 3: Run vite install if requested
   if (inputs.runInstall.length > 0) {
-    await runViteInstall(inputs)
+    await runViteInstall(inputs);
   }
 }
 
 async function runPost(inputs: Inputs): Promise<void> {
   // Save cache if enabled
   if (inputs.cache) {
-    await saveCache()
+    await saveCache();
   }
 }
 
 async function main(): Promise<void> {
-  const inputs = getInputs()
+  const inputs = getInputs();
 
-  if (getState(State.IsPost) === 'true') {
-    await runPost(inputs)
+  if (getState(State.IsPost) === "true") {
+    await runPost(inputs);
   } else {
-    await runMain(inputs)
+    await runMain(inputs);
   }
 }
 
-main().catch(error => {
-  console.error(error)
-  setFailed(error instanceof Error ? error.message : String(error))
-})
+main().catch((error) => {
+  console.error(error);
+  setFailed(error instanceof Error ? error.message : String(error));
+});