@10stars/config 15.6.0 → 15.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@10stars/config",
-  "version": "15.6.0",
+  "version": "15.6.2",
   "private": false,
   "bin": {
     "config": "./src/index.ts"

package/src/index.ts

@@ -4,7 +4,7 @@ import fs from "node:fs/promises"
 import path from "node:path"
 
 import { resetColorIndex } from "./colors"
-import { checkIsMonorepo, linkPackages } from "./link-packages"
+import { checkIsMonorepo, dedupeSingletons, linkPackages } from "./link-packages"
 import { setupOverrides } from "./manage-overrides"
 import { runConcurrently, type CommandConfig } from "./runner"
 import { setupVSCode } from "./vscode-config"
@@ -13,6 +13,7 @@ const cwd = process.env.PWD!
 
 interface Config {
   linkPackages: string[]
+  dedupeSingletons?: boolean | string[]
 }
 
 const exec = (cmd: string) => {
@@ -55,7 +56,15 @@ const actions = {
       await setupOverrides(cwd) // sync standardized package.json overrides
 
       const config = await getConfig()
-      if (config?.linkPackages) await linkPackages(cwd, config.linkPackages)
+      if (config?.linkPackages) {
+        const linkedPaths = await linkPackages(cwd, config.linkPackages)
+        if (config.dedupeSingletons !== false) {
+          const singletons = Array.isArray(config.dedupeSingletons)
+            ? config.dedupeSingletons
+            : undefined
+          await dedupeSingletons(cwd, config.linkPackages, linkedPaths, singletons)
+        }
+      }
     },
   },
   typecheckWatch: {

package/src/link-packages.ts

@@ -24,6 +24,8 @@ export const checkIsMonorepo = async (pathPkg: string) => {
 }
 
 export const linkPackages = async (cwd: string, packagesToLink: string[]) => {
+  const linkedPaths: string[] = []
+
   const linkPackage = async (pathPkg: string) => {
     const pkgJson: TF.PackageJson = await import(path.join(pathPkg, `package.json`)).catch(
       () => null,
@@ -33,42 +35,104 @@ export const linkPackages = async (cwd: string, packagesToLink: string[]) => {
     const [orgName, pkgName] = pkgJson.name!.split(`/`)
 
     const pathSymlink = path.join(cwd, `node_modules`, orgName, pkgName)
-    return symlink(pathPkg, pathSymlink)
+    await symlink(pathPkg, pathSymlink)
+    linkedPaths.push(pathPkg)
   }
 
-  const promises: Promise<unknown>[] = []
-  for (const relativePath of packagesToLink) {
-    const pathPkg = path.join(cwd, relativePath)
-    promises.push(
-      checkIsMonorepo(pathPkg)
-        .catch(() => null) // relative path might point to a non-existing directory for a particular developer; skip linking a particular package in that case
-        .then(async (isMonorepo) => {
-          if (!isMonorepo) return promises.push(linkPackage(pathPkg))
-
-          const files = await fs.readdir(relativePath, { withFileTypes: true }).catch(() => null)
-          if (!files) return
-
-          const directories = files.filter((v) => v.isDirectory()).map((v) => v.name)
-          const packages = (
-            await Promise.all(
-              directories.map(async (v) => {
-                const pathPkg = path.join(cwd, relativePath, v)
-                const pkgJson: TF.PackageJson = await import(
-                  path.join(pathPkg, `package.json`)
-                ).catch(() => null)
-                if (pkgJson) return v
-              }),
-            )
-          ).filter(Boolean)
-          for (const pkg of packages) {
-            const relativePathToPkg = path.join(cwd, relativePath, pkg!)
-            promises.push(linkPackage(relativePathToPkg))
-          }
-        }),
-    )
-  }
+  await Promise.all(
+    packagesToLink.map(async (relativePath) => {
+      const pathPkg = path.join(cwd, relativePath)
 
-  await Promise.all(promises)
+      // relative path might point to a non-existing directory for a particular developer; skip linking that package in that case
+      const isMonorepo = await checkIsMonorepo(pathPkg).catch(() => null)
+      if (!isMonorepo) return linkPackage(pathPkg)
+
+      const files = await fs.readdir(relativePath, { withFileTypes: true }).catch(() => null)
+      if (!files) return
+
+      const directories = files.filter((v) => v.isDirectory()).map((v) => v.name)
+      await Promise.all(directories.map((dir) => linkPackage(path.join(cwd, relativePath, dir))))
+    }),
+  )
 
   console.info(`Successfully linked local packages!`)
+
+  return linkedPaths
+}
+
+const DEFAULT_SINGLETONS = [`@types/react`, `@types/react-dom`]
+
+const readPkgVersion = async (pathPkg: string): Promise<string | null> => {
+  const pkgJson: TF.PackageJson = await import(path.join(pathPkg, `package.json`)).catch(() => null)
+  return pkgJson?.version ?? null
+}
+
+const majorOf = (version: string) => version.split(`.`)[0]
+
+/**
+ * Collapse React type singletons to one physical copy for locally-linked graphs.
+ *
+ * tsgo resolves symlinked deps at their realpath and ignores the consumer's tsconfig
+ * `paths`, so multiple physical `@types/react` copies become distinct type identities.
+ * Pointing every copy at the workspace-root copy replicates a hoisted monorepo (one type
+ * identity). Best-effort and idempotent: a plain `bun install` re-materializes real dirs and
+ * the next `prepare` re-establishes the symlinks.
+ */
+export const dedupeSingletons = async (
+  cwd: string,
+  packagesToLink: string[],
+  linkedPaths: string[],
+  singletons: string[] = DEFAULT_SINGLETONS,
+) => {
+  // siblings share cwd's parent; the formula reduces to path.dirname(cwd) for `../pkg` entries
+  const roots = new Set(packagesToLink.map((rel) => path.resolve(cwd, rel, `..`)))
+  const workspaceRoot = roots.size === 1 ? [...roots][0]! : path.dirname(cwd)
+
+  for (const pkg of singletons) {
+    const canonical = path.join(workspaceRoot, `node_modules`, pkg)
+    const canonicalVersion = await readPkgVersion(canonical)
+    if (!canonicalVersion) {
+      console.warn(`Dedupe ${pkg}: canonical copy not found at ${canonical}; skipping`)
+      continue
+    }
+    const canonicalReal = await fs.realpath(canonical).catch(() => canonical)
+
+    const targets = [
+      path.join(cwd, `node_modules`, pkg),
+      ...linkedPaths.map((pathPkg) => path.join(pathPkg, `node_modules`, pkg)),
+    ]
+
+    let relinked = 0
+    let skipped = 0
+
+    for (const target of targets) {
+      if (path.resolve(target) === path.resolve(canonical)) continue
+
+      const stats = await fs.lstat(target).catch(() => null)
+      if (!stats) continue
+
+      if (stats.isSymbolicLink()) {
+        const real = await fs.realpath(target).catch(() => null)
+        if (real === canonicalReal) continue // already deduped
+      }
+
+      const targetVersion = await readPkgVersion(target)
+      if (!targetVersion) continue
+
+      if (majorOf(targetVersion) !== majorOf(canonicalVersion)) {
+        skipped++
+        console.warn(
+          `Dedupe ${pkg}: skipping ${target} (v${targetVersion}); major differs from canonical v${canonicalVersion}`,
+        )
+        continue
+      }
+
+      await symlink(canonicalReal, target)
+      relinked++
+    }
+
+    console.info(
+      `Dedupe ${pkg}@${canonicalVersion}: ${relinked} copy(ies) relinked, ${skipped} skipped`,
+    )
+  }
 }

package/src/manage-overrides.ts

@@ -51,9 +51,15 @@ export const setupOverrides = async (cwd: string) => {
   const merged = { ...pkgJson.overrides, ...managedOverrides }
   const sorted = Object.fromEntries(Object.entries(merged).sort(([a], [b]) => a.localeCompare(b)))
 
+  const changed = JSON.stringify(pkgJson.overrides ?? {}) !== JSON.stringify(sorted)
+  if (!changed) return
+
   pkgJson.overrides = sorted
 
   await fs.writeFile(pkgPath, JSON.stringify(pkgJson, null, 2) + `\n`)
   console.info(`Written: ${pkgPath}`)
   execSync(`bunx oxfmt ${pkgPath}`, { cwd, stdio: `inherit` })
+
+  console.info(`Overrides changed, running "bun install"...`)
+  execSync(`bun install`, { cwd, stdio: `inherit` })
 }