@10stars/config 17.0.7 → 17.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@10stars/config",
-  "version": "17.0.7",
+  "version": "17.0.9",
   "private": false,
   "bin": {
     "config": "./src/index.ts"
@@ -27,9 +27,9 @@
     "@types/react": "^19.2.17",
     "@types/react-dom": "^19.2.3",
     "husky": "^9.1.7",
-    "oxfmt": "0.58.0",
-    "oxlint": "^1.73.0",
-    "oxlint-tsgolint": "^0.24.0",
+    "oxfmt": "0.59.0",
+    "oxlint": "^1.74.0",
+    "oxlint-tsgolint": "^0.25.0",
     "tsx": "^4.23.1",
     "type-fest": "^5.8.0",
     "typescript": "7.0.2"

package/src/index.ts

@@ -8,8 +8,7 @@ import { dedupeRemote, linkRemote } from "./linking/link-remote"
 import { setupOverrides } from "./manage-overrides"
 import { resetColorIndex } from "./run/colors"
 import { runConcurrently, type CommandConfig } from "./run/runner"
-import { setupSideEffects } from "./vanilla-extract/manage-side-effects"
-import { patchVanillaExtract } from "./vanilla-extract/patch-vanilla-extract"
+import { isVanillaExtractInstalled, setupSideEffects } from "./vanilla-extract/manage-side-effects"
 import { setupVSCode } from "./vscode-config"
 
 const cwd = process.env.PWD!
@@ -45,8 +44,6 @@ const actions = {
   prepare: {
     info: `Runs husky and links packages`,
     action: async () => {
-      const veInstalled = await patchVanillaExtract(cwd) // patch VE before the CI guard: builds (incl. CI) need the `css.ts`-only filter in node_modules
-
       await linkSelf(cwd) // before the CI guard: CI app builds also self-import `<pkg>/src/…`
 
       if (process.env.CI) return
@@ -59,7 +56,7 @@ const actions = {
       exec(`husky`) // husky is intended only for local development (not in CI)
       await setupVSCode(cwd) // create/update .vscode directory with standardized extensions.json and settings.json
       await setupOverrides(cwd) // sync standardized package.json overrides
-      await setupSideEffects(cwd, veInstalled) // CSS-protect VE repos; `sideEffects: false` for non-VE libs
+      await setupSideEffects(cwd, isVanillaExtractInstalled(cwd)) // CSS-protect VE repos; `sideEffects: false` for non-VE libs
 
       const config = await getConfig()
       if (config?.linkPackages) {

package/src/linking/link-remote.ts

@@ -64,11 +64,11 @@ const tryGit = (args: string[], cwd?: string): string | null => {
 }
 
 // --ignore-scripts: a sibling is only a dependency here, so skip its postinstall (`config prepare`)
-// — its Vanilla-Extract patch isn't needed (nothing builds it; typecheck doesn't run VE) and the
-// cross-repo `@types/*` dedupe runs once via the consumer's `dedupe` afterwards. We still restore
-// the one thing a sibling's own src needs: its self-symlink, so `<self>/src/…` self-imports resolve
-// at realpath in the flat-peer layout. (Workspace-root siblings, e.g. backend-api, get their
-// subpackage self-links from bun's own workspace linking, so linkSelf no-ops on them.)
+// — nothing builds it (typecheck doesn't run VE) and the cross-repo `@types/*` dedupe runs once via
+// the consumer's `dedupe` afterwards. We still restore the one thing a sibling's own src needs: its
+// self-symlink, so `<self>/src/…` self-imports resolve at realpath in the flat-peer layout.
+// (Workspace-root siblings, e.g. backend-api, get their subpackage self-links from bun's own
+// workspace linking, so linkSelf no-ops on them.)
 const bunInstall = async (cwd: string): Promise<void> => {
   await execFileAsync(`bun`, [`install`, `--ignore-scripts`], { cwd })
   await linkSelf(cwd)

package/src/vanilla-extract/manage-side-effects.ts

@@ -1,15 +1,30 @@
 import { execSync } from "node:child_process"
 import fs from "node:fs/promises"
+import { createRequire } from "node:module"
 import path from "node:path"
 
 import type * as TF from "type-fest"
 
+/**
+ * Whether Vanilla Extract is installed for `cwd` — resolved from `@vanilla-extract/integration`
+ * (pulled in by the vite-plugin/compiler), the same signal the old on-disk patch keyed off. Gates
+ * `setupSideEffects` so only VE repos get their `css.ts`/`.css` imports protected from tree-shaking.
+ */
+export const isVanillaExtractInstalled = (cwd: string): boolean => {
+  try {
+    createRequire(path.join(cwd, `package.json`)).resolve(`@vanilla-extract/integration`)
+    return true
+  } catch {
+    return false
+  }
+}
+
 // VE `css.ts` modules and raw `.css` files inject styles purely as a side effect — a global reset,
 // theme-var override or `@font-face` is imported for that effect alone (no used exports). A
 // `sideEffects: false` package tree-shakes such a bare import away, shipping an unstyled build (and,
 // on SSR, a hydration mismatch — React #418 — since the server-rendered markup no longer matches).
-// Listing them keeps them alive. `css.ts` mirrors the single-filename VE convention (see
-// patch-vanilla-extract); `.tsx`/`.js` css variants aren't used in these repos.
+// Listing them keeps them alive. `css.ts` mirrors the single-filename VE convention; `.tsx`/`.js`
+// css variants aren't used in these repos.
 const CSS_SIDE_EFFECTS = [`**/css.ts`, `**/*.css`]
 
 /**

package/src/vanilla-extract/patch-vanilla-extract.ts

@@ -1,89 +0,0 @@
-import fs from "node:fs/promises"
-import path from "node:path"
-
-// Vanilla Extract hardcodes its file filter as a `const` regex in @vanilla-extract/integration and
-// imports it into both its vite-plugin and its compiler — there's no option to customize it. We
-// rewrite the regex on disk so ONLY `css.ts` (our single-filename convention) is treated as a VE
-// module; the conventional `.css.ts` suffix is intentionally no longer matched.
-//   original: matches any `*.css.ts`      (a `.` may precede `css`)
-//   patched:  matches a `css.ts` filename (only start-of-path or a separator may precede `css`)
-const ORIGINAL = String.raw`/\.css\.(js|cjs|mjs|jsx|ts|tsx)(\?used)?$/`
-const PATCHED = String.raw`/(?:^|[/\\])css\.(js|cjs|mjs|jsx|ts|tsx)(\?used)?$/`
-
-/**
- * Rewrite VE's `cssFileFilter` to a `css.ts`-only matcher in every installed copy.
- *
- * Runs on `prepare` (postinstall), so it re-applies after each `bun install` re-materializes
- * node_modules. Idempotent, and a no-op for repos without VE (e.g. backend-only). If VE is present
- * but the filter definition can't be found, it throws: a silent miss would stop every `css.ts` from
- * compiling, so a VE build change must surface at install time rather than as missing styles.
- *
- * @returns whether VE is installed here — the caller uses it to gate `css.ts` side-effect handling.
- */
-export const patchVanillaExtract = async (cwd: string): Promise<boolean> => {
-  const nodeModules = path.join(cwd, `node_modules`)
-
-  // Collect every real `@vanilla-extract/integration/dist/*.js`. VE always sits directly under a
-  // `node_modules` dir, so we read each node_modules' own integration/dist and recurse ONLY into
-  // *nested* node_modules — never into package source trees. (A flat hoisted tree is hundreds of
-  // packages; recursing each one's dist/esm/cjs/… was the bulk of the old cost.) Symlinks are
-  // skipped: a `file:` self-dep links node_modules/<pkg> -> repo root, so following links recurses
-  // forever — also why Bun.Glob (which follows links even with `followSymlinks: false`) can't be
-  // used. A linked sibling patches its own VE during its own install; this repo's copy is hoisted
-  // as a real dir, so real-dir-only descent finds every copy that this install must patch.
-  const findFiles = async (dir: string, out: string[] = []): Promise<string[]> => {
-    const distDir = path.join(dir, `@vanilla-extract`, `integration`, `dist`)
-    for (const entry of await fs.readdir(distDir, { withFileTypes: true }).catch(() => [])) {
-      if (entry.isFile() && entry.name.endsWith(`.js`)) out.push(path.join(distDir, entry.name))
-    }
-
-    for (const entry of await fs.readdir(dir, { withFileTypes: true }).catch(() => [])) {
-      if (entry.isSymbolicLink() || !entry.isDirectory()) continue
-      const pkgDir = path.join(dir, entry.name)
-      if (entry.name.startsWith(`@`)) {
-        // scoped packages nest a level deeper: node_modules/@scope/<pkg>/node_modules
-        for (const scoped of await fs.readdir(pkgDir, { withFileTypes: true }).catch(() => [])) {
-          if (scoped.isSymbolicLink() || !scoped.isDirectory()) continue
-          await findFiles(path.join(pkgDir, scoped.name, `node_modules`), out)
-        }
-      } else {
-        await findFiles(path.join(pkgDir, `node_modules`), out)
-      }
-    }
-    return out
-  }
-
-  let integrationFound = false
-  let definitionFound = false
-  const patched: string[] = []
-
-  for (const file of await findFiles(nodeModules)) {
-    integrationFound = true
-    const content = await fs.readFile(file, `utf8`)
-
-    if (content.includes(PATCHED)) {
-      definitionFound = true // already patched by an earlier run
-      continue
-    }
-    if (!content.includes(ORIGINAL)) continue // entry stub / file without the filter definition
-
-    definitionFound = true
-    await fs.writeFile(file, content.replaceAll(ORIGINAL, PATCHED))
-    patched.push(path.relative(nodeModules, file))
-  }
-
-  if (!integrationFound) return false // VE not installed here
-
-  if (!definitionFound) {
-    throw new Error(
-      `@10stars/config: found @vanilla-extract/integration but not its cssFileFilter definition — ` +
-        `the VE build likely changed. Update ORIGINAL in src/vanilla-extract/patch-vanilla-extract.ts.`,
-    )
-  }
-
-  if (patched.length) {
-    console.info(`Patched @vanilla-extract file filter to css.ts (${patched.length} file(s))`)
-  }
-
-  return true
-}