@ttsc/strip 0.16.7 → 0.16.9

package/driver/config.go

@@ -290,7 +290,7 @@ try {
 // project's transform/check plugins would be wasteful and could fail the
 // build against this deliberately lenient loader tsconfig.
 func loadStripTypeScriptConfigFile(location string) (any, error) {
-  tempDir, err := os.MkdirTemp("", "ttsc-strip-config-")
+  tempDir, err := os.MkdirTemp(stripLoaderTempBase(location, os.TempDir()), "ttsc-strip-config-")
   if err != nil {
     return nil, fmt.Errorf("@ttsc/strip: create config loader tempdir: %w", err)
   }
@@ -366,7 +366,7 @@ func stripTypeScriptLoaderTsconfig(loader, location, outDir string) string {
       "noImplicitAny":                   false,
       "outDir":                          filepath.ToSlash(filepath.Join(outDir, "out")),
       "rewriteRelativeImportExtensions": true,
-      "rootDir":                         "/",
+      "rootDir":                         stripLoaderRootDir(outDir),
       "skipLibCheck":                    true,
       "strict":                          false,
       "target":                          "ES2022",
@@ -383,6 +383,78 @@ func stripTypeScriptLoaderTsconfig(loader, location, outDir string) string {
   return string(body)
 }
 
+// stripLoaderRootDir returns the widest rootDir that still contains the
+// loader tsconfig's inputs: the volume root of the loader temp dir (`C:/` on
+// Windows, `/` elsewhere). A literal "/" is not an ancestor of drive-letter
+// paths, so tsgo rejects every input with TS6059 (#299, #304). The temp dir
+// is created on the same volume as the config file (see stripLoaderTempBase),
+// so its volume root spans both `files` entries.
+func stripLoaderRootDir(outDir string) string {
+  vol := filepath.VolumeName(outDir)
+  if vol == "" {
+    return "/"
+  }
+  return filepath.ToSlash(vol + `\`)
+}
+
+// stripLoaderTempBase picks the parent directory for the ephemeral
+// config-loader tree. The system temp dir is the default, but when it sits on
+// a different volume than the config file (Windows: TEMP on `C:`, project on
+// `D:`) the loader cannot work from there — no single tsconfig rootDir spans
+// two volumes and filepath.Rel cannot produce a relative import across drives
+// (#305) — so the tree is created under the config's nearest
+// node_modules/.cache instead, falling back to the config's own directory
+// when no node_modules exists (or its .cache cannot be created): any location
+// on the config's volume beats the system temp dir, which is guaranteed to
+// fail. Returns "" (the os.MkdirTemp default) when the volumes already match.
+func stripLoaderTempBase(location, systemTemp string) string {
+  // A relative location has no volume; "" must not be read as "a volume
+  // other than the system temp's" — it keeps the historical default (and
+  // the Rel-failure contract for relative config paths).
+  vol := filepath.VolumeName(location)
+  if vol == "" || strings.EqualFold(filepath.VolumeName(systemTemp), vol) {
+    return ""
+  }
+  nodeModules := stripFindNearestNodeModules(filepath.Dir(location))
+  if nodeModules == "" {
+    return filepath.Dir(location)
+  }
+  // Resolve a linked node_modules (junction/symlink — common in managed
+  // setups) before descending into it: the ESM runtime realpaths the loader
+  // module at import time, and a relative config specifier computed from the
+  // link-form path would resolve against the wrong directory. NTFS junctions
+  // defeat filepath.EvalSymlinks, so the link component is chased by hand
+  // first. Realpathing may also land on another volume, which defeats the
+  // whole point — fall back to the config's directory then.
+  base := filepath.Join(stripResolveDirLink(nodeModules), ".cache")
+  if err := os.MkdirAll(base, 0o755); err != nil {
+    return filepath.Dir(location)
+  }
+  real, err := filepath.EvalSymlinks(base)
+  if err != nil || !strings.EqualFold(filepath.VolumeName(real), filepath.VolumeName(location)) {
+    return filepath.Dir(location)
+  }
+  return real
+}
+
+// stripResolveDirLink chases a directory that is itself a symlink or NTFS junction
+// to its target (bounded against link cycles). os.Readlink is the probe:
+// it resolves junctions, which report neither ModeSymlink nor an
+// EvalSymlinks-traversable path.
+func stripResolveDirLink(dir string) string {
+  for i := 0; i < 8; i++ {
+    target, err := os.Readlink(dir)
+    if err != nil {
+      return dir
+    }
+    if !filepath.IsAbs(target) {
+      target = filepath.Join(filepath.Dir(dir), target)
+    }
+    dir = target
+  }
+  return dir
+}
+
 // stripTtsxCommandContext returns an exec.Cmd that runs ttsx with the given
 // arguments, routing through node when the resolved binary is a script file.
 func stripTtsxCommandContext(ctx context.Context, args ...string) *exec.Cmd {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ttsc/strip",
-  "version": "0.16.7",
+  "version": "0.16.9",
   "description": "First-party ttsc plugin that removes configured calls and statements from emitted JavaScript.",
   "main": "src/index.cjs",
   "types": "src/index.d.ts",