@nifrajs/ts-plugin 3.1.0 → 3.3.0

package/dist/index.cjs

@@ -83,6 +83,97 @@ function findRoutesDir(fromFile, exists = import_node_fs.existsSync) {
   }
   return;
 }
+function normalizeProgramPath(fileName) {
+  const slashed = fileName.replaceAll("\\", "/");
+  const withoutDevicePrefix = slashed.replace(/^\/\/\?\/UNC\//i, "//").replace(/^\/\/\?\//, "");
+  return process.platform === "win32" ? withoutDevicePrefix.toLowerCase() : withoutDevicePrefix;
+}
+function canonicalProgramPaths(tsm, fileName) {
+  const absolute = import_node_path.resolve(fileName);
+  const paths = new Set([normalizeProgramPath(absolute)]);
+  const tsmRealpath = tsm.sys.realpath;
+  const resolvers = [
+    ...typeof tsmRealpath === "function" ? [tsmRealpath] : [],
+    import_node_fs.realpathSync.native,
+    import_node_fs.realpathSync
+  ];
+  for (const resolver of resolvers) {
+    try {
+      paths.add(normalizeProgramPath(resolver(absolute)));
+    } catch {}
+  }
+  return [...paths];
+}
+function typeScriptProgramPath(tsm, program, fileName) {
+  const toPath = tsm.toPath;
+  if (typeof toPath !== "function")
+    return;
+  const getCanonicalFileName = tsm.sys.useCaseSensitiveFileNames ? (value) => value : (value) => value.toLowerCase();
+  try {
+    return toPath(import_node_path.resolve(fileName), program.getCurrentDirectory(), getCanonicalFileName);
+  } catch {
+    return;
+  }
+}
+function filesystemIdentity(fileName) {
+  try {
+    const info = import_node_fs.statSync(import_node_path.resolve(fileName), { bigint: true });
+    if (info.ino === 0n)
+      return;
+    return `bigint:${info.dev}:${info.ino}`;
+  } catch {
+    try {
+      const info = import_node_fs.statSync(import_node_path.resolve(fileName));
+      if (info.ino === 0)
+        return;
+      return `number:${info.dev}:${info.ino}`;
+    } catch {
+      return;
+    }
+  }
+}
+function programSourceFile(tsm, program, fileName) {
+  if (program === undefined)
+    return;
+  const direct = program.getSourceFile(fileName);
+  if (direct !== undefined)
+    return direct;
+  const programPath = typeScriptProgramPath(tsm, program, fileName);
+  if (programPath !== undefined) {
+    const byTypeScriptPath = program.getSourceFileByPath(programPath);
+    if (byTypeScriptPath !== undefined)
+      return byTypeScriptPath;
+  }
+  const wanted = new Set(canonicalProgramPaths(tsm, fileName));
+  const byPath = program.getSourceFiles().find((source) => canonicalProgramPaths(tsm, source.fileName).some((path) => wanted.has(path)));
+  if (byPath !== undefined)
+    return byPath;
+  const wantedIdentity = filesystemIdentity(fileName);
+  if (wantedIdentity === undefined)
+    return;
+  return program.getSourceFiles().find((source) => filesystemIdentity(source.fileName) === wantedIdentity);
+}
+function hostSourceFile(tsm, host, program, fileName) {
+  if (host === undefined)
+    return;
+  const snapshot = host.getScriptSnapshot(fileName);
+  if (snapshot === undefined)
+    return;
+  const text = snapshot.getText(0, snapshot.getLength());
+  const options = program?.getCompilerOptions();
+  const getScriptKindFromFileName = tsm.getScriptKindFromFileName;
+  return tsm.createSourceFile(fileName, text, options?.target ?? tsm.ScriptTarget.Latest, true, host.getScriptKind?.(fileName) ?? (typeof getScriptKindFromFileName === "function" ? getScriptKindFromFileName(fileName) : tsm.ScriptKind.TSX));
+}
+function diskSourceFile(tsm, program, fileName) {
+  let text;
+  try {
+    text = import_node_fs.readFileSync(fileName, "utf8");
+  } catch {
+    return;
+  }
+  const getScriptKindFromFileName = tsm.getScriptKindFromFileName;
+  return tsm.createSourceFile(fileName, text, program?.getCompilerOptions().target ?? tsm.ScriptTarget.Latest, true, typeof getScriptKindFromFileName === "function" ? getScriptKindFromFileName(fileName) : tsm.ScriptKind.TSX);
+}
 function innermostNodeAt(tsm, source, node, position) {
   if (position < node.getStart(source) || position > node.getEnd())
     return;
@@ -103,8 +194,9 @@ function findRoutePathLiteral(tsm, source, position) {
   const start = node.getStart(source) + 1;
   return { text: node.text, span: { start, length: Math.max(0, node.getWidth(source) - 2) } };
 }
-function routeDefinitionAt(tsm, ls, fileName, position) {
-  const source = ls.getProgram()?.getSourceFile(fileName);
+function routeDefinitionAt(tsm, ls, host, fileName, position) {
+  const program = ls.getProgram();
+  const source = programSourceFile(tsm, program, fileName) ?? hostSourceFile(tsm, host, program, fileName) ?? diskSourceFile(tsm, program, fileName);
   if (source === undefined)
     return;
   const literal = findRoutePathLiteral(tsm, source, position);
@@ -147,9 +239,18 @@ function init(modules) {
       const writable = proxy;
       for (const key of Object.keys(ls)) {
         const member = ls[key];
-        writable[key] = typeof member === "function" ? member.bind(ls) : member;
+        writable[key] = typeof member === "function" ? (...args) => {
+          const fileName = args[0];
+          const source = typeof fileName === "string" ? programSourceFile(tsm, ls.getProgram(), fileName) : undefined;
+          return member.apply(ls, [
+            ...source === undefined ? args : [source.fileName, ...args.slice(1)]
+          ]);
+        } : member;
       }
-      proxy.getDefinitionAndBoundSpan = (fileName, position) => routeDefinitionAt(tsm, ls, fileName, position) ?? ls.getDefinitionAndBoundSpan(fileName, position);
+      proxy.getDefinitionAndBoundSpan = (fileName, position) => routeDefinitionAt(tsm, ls, info.languageServiceHost, fileName, position) ?? (() => {
+        const source = programSourceFile(tsm, ls.getProgram(), fileName);
+        return source === undefined ? undefined : ls.getDefinitionAndBoundSpan(source.fileName, position);
+      })();
       return proxy;
     }
   };

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAA;AAGrC,sGAAsG;AACtG,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAoB,GAC1C,MAAM,GAAG,SAAS,CASpB;AAkBD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,OAAO,EAAE,EACd,MAAM,EAAE,EAAE,CAAC,UAAU,EACrB,QAAQ,EAAE,MAAM,GACf;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAA;CAAE,GAAG,SAAS,CAMjD;AAuCD,iBAAS,IAAI,CAAC,OAAO,EAAE;IAAE,UAAU,EAAE,OAAO,EAAE,CAAA;CAAE,GAAG,EAAE,CAAC,MAAM,CAAC,YAAY,CAuBxE;AAED,eAAe,IAAI,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,KAAK,EAAE,MAAM,YAAY,CAAA;AAGrC,sGAAsG;AACtG,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAChB,MAAM,GAAE,CAAC,CAAC,EAAE,MAAM,KAAK,OAAoB,GAC1C,MAAM,GAAG,SAAS,CASpB;AAgMD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,OAAO,EAAE,EACd,MAAM,EAAE,EAAE,CAAC,UAAU,EACrB,QAAQ,EAAE,MAAM,GACf;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,EAAE,CAAC,QAAQ,CAAA;CAAE,GAAG,SAAS,CAMjD;AA4CD,iBAAS,IAAI,CAAC,OAAO,EAAE;IAAE,UAAU,EAAE,OAAO,EAAE,CAAA;CAAE,GAAG,EAAE,CAAC,MAAM,CAAC,YAAY,CA6CxE;AAED,eAAe,IAAI,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nifrajs/ts-plugin",
-  "version": "3.1.0",
+  "version": "3.3.0",
   "description": "TypeScript language-service plugin for nifra - go-to-definition from a route-path string literal to the routes/ file that serves it.",
   "keywords": [
     "bun",
@@ -44,8 +44,8 @@
     "build": "bun run build.ts"
   },
   "dependencies": {
-    "@nifrajs/core": "3.1.0",
-    "@nifrajs/web": "3.1.0"
+    "@nifrajs/core": "3.3.0",
+    "@nifrajs/web": "3.3.0"
   },
   "peerDependencies": {
     "typescript": ">=5.5.0"

package/src/index.ts

@@ -12,8 +12,8 @@
  * matches with `@nifrajs/core`'s pattern matcher (see ./resolve.ts), so a path resolves to exactly the
  * file it would serve at runtime. The plugin only wires that into `getDefinitionAndBoundSpan`.
  */
-import { existsSync } from "node:fs"
-import { dirname, isAbsolute, join } from "node:path"
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs"
+import { dirname, isAbsolute, join, resolve } from "node:path"
 import { discoverRoutes } from "@nifrajs/web/fs"
 import type * as ts from "typescript"
 import { resolveRouteFile } from "./resolve.ts"
@@ -33,6 +33,180 @@ export function findRoutesDir(
   return undefined
 }
 
+/**
+ * TypeScript can canonicalize a file through its host while the editor hands the plugin a different
+ * spelling. Windows CI exposes this as the short `RUNNER~1` temp path versus the long path stored in
+ * the Program. Match by filesystem identity before delegating to TypeScript; a failed realpath falls
+ * back to the lexical absolute path so a missing or synthetic file is still handled normally.
+ */
+function normalizeProgramPath(fileName: string): string {
+  const slashed = fileName.replaceAll("\\", "/")
+  const withoutDevicePrefix = slashed.replace(/^\/\/\?\/UNC\//i, "//").replace(/^\/\/\?\//, "")
+  return process.platform === "win32" ? withoutDevicePrefix.toLowerCase() : withoutDevicePrefix
+}
+
+/** Keep every spelling a filesystem resolver may return; native and portable realpath disagree on
+ * some Windows short-name paths, so matching only one of them is still a false negative. */
+function canonicalProgramPaths(tsm: typeof ts, fileName: string): readonly string[] {
+  const absolute = resolve(fileName)
+  const paths = new Set<string>([normalizeProgramPath(absolute)])
+  const tsmRealpath = tsm.sys.realpath
+  const resolvers = [
+    ...(typeof tsmRealpath === "function" ? [tsmRealpath] : []),
+    realpathSync.native,
+    realpathSync,
+  ]
+  for (const resolver of resolvers) {
+    try {
+      paths.add(normalizeProgramPath(resolver(absolute)))
+    } catch {
+      // Synthetic editor files and a path removed during an edit have no realpath. The absolute
+      // spelling remains a valid candidate for TypeScript's virtual source overlay.
+    }
+  }
+  return [...paths]
+}
+
+/**
+ * TypeScript keeps an internal, canonical `Path` for every source file. Prefer that lookup when it
+ * is available: unlike a direct string comparison it applies the same case/normalization rules the
+ * Program used while loading the file. This is important on Windows, where the language service can
+ * receive an 8.3 spelling (`RUNNER~1`) while the Program was populated from the long spelling.
+ */
+function typeScriptProgramPath(
+  tsm: typeof ts,
+  program: ts.Program,
+  fileName: string,
+): ts.Path | undefined {
+  const toPath = (
+    tsm as unknown as {
+      toPath?: (
+        fileName: string,
+        currentDirectory: string,
+        getCanonicalFileName: (fileName: string) => string,
+      ) => ts.Path
+    }
+  ).toPath
+  if (typeof toPath !== "function") return undefined
+  const getCanonicalFileName = tsm.sys.useCaseSensitiveFileNames
+    ? (value: string): string => value
+    : (value: string): string => value.toLowerCase()
+  try {
+    return toPath(resolve(fileName), program.getCurrentDirectory(), getCanonicalFileName)
+  } catch {
+    return undefined
+  }
+}
+
+/** Match a real file even when Windows handed the editor an 8.3 alias for the same path. */
+function filesystemIdentity(fileName: string): string | undefined {
+  try {
+    const info = statSync(resolve(fileName), { bigint: true })
+    if (info.ino === 0n) return undefined
+    return `bigint:${info.dev}:${info.ino}`
+  } catch {
+    try {
+      const info = statSync(resolve(fileName))
+      if (info.ino === 0) return undefined
+      return `number:${info.dev}:${info.ino}`
+    } catch {
+      // TypeScript also exposes virtual/source-overlay files. They have no filesystem identity, so
+      // the lexical/realpath checks remain the correct fallback for those inputs.
+      return undefined
+    }
+  }
+}
+
+function programSourceFile(
+  tsm: typeof ts,
+  program: ts.Program | undefined,
+  fileName: string,
+): ts.SourceFile | undefined {
+  if (program === undefined) return undefined
+  const direct = program.getSourceFile(fileName)
+  if (direct !== undefined) return direct
+
+  // `getSourceFileByPath` is the Program's own canonical lookup. It is deliberately attempted before
+  // the filesystem scans below because an editor may provide a virtual source overlay that has no
+  // stat/realpath identity at all.
+  const programPath = typeScriptProgramPath(tsm, program, fileName)
+  if (programPath !== undefined) {
+    const byTypeScriptPath = program.getSourceFileByPath(programPath)
+    if (byTypeScriptPath !== undefined) return byTypeScriptPath
+  }
+
+  const wanted = new Set(canonicalProgramPaths(tsm, fileName))
+  const byPath = program
+    .getSourceFiles()
+    .find((source) => canonicalProgramPaths(tsm, source.fileName).some((path) => wanted.has(path)))
+  if (byPath !== undefined) return byPath
+
+  const wantedIdentity = filesystemIdentity(fileName)
+  if (wantedIdentity === undefined) return undefined
+  return program
+    .getSourceFiles()
+    .find((source) => filesystemIdentity(source.fileName) === wantedIdentity)
+}
+
+/** Parse the editor's current snapshot when the Program has canonicalized the on-disk path under a
+ * different spelling. This keeps route navigation correct for unsaved edits too; reading from disk
+ * here would make the plugin jump based on stale source while an editor buffer is open. */
+function hostSourceFile(
+  tsm: typeof ts,
+  host: ts.LanguageServiceHost | undefined,
+  program: ts.Program | undefined,
+  fileName: string,
+): ts.SourceFile | undefined {
+  if (host === undefined) return undefined
+  const snapshot = host.getScriptSnapshot(fileName)
+  if (snapshot === undefined) return undefined
+  const text = snapshot.getText(0, snapshot.getLength())
+  const options = program?.getCompilerOptions()
+  const getScriptKindFromFileName = (
+    tsm as unknown as {
+      getScriptKindFromFileName?: (fileName: string) => ts.ScriptKind
+    }
+  ).getScriptKindFromFileName
+  return tsm.createSourceFile(
+    fileName,
+    text,
+    options?.target ?? tsm.ScriptTarget.Latest,
+    true,
+    host.getScriptKind?.(fileName) ??
+      (typeof getScriptKindFromFileName === "function"
+        ? getScriptKindFromFileName(fileName)
+        : tsm.ScriptKind.TSX),
+  )
+}
+
+/** Last-resort source overlay for embedders that omit `languageServiceHost` from PluginCreateInfo. */
+function diskSourceFile(
+  tsm: typeof ts,
+  program: ts.Program | undefined,
+  fileName: string,
+): ts.SourceFile | undefined {
+  let text: string
+  try {
+    text = readFileSync(fileName, "utf8")
+  } catch {
+    return undefined
+  }
+  const getScriptKindFromFileName = (
+    tsm as unknown as {
+      getScriptKindFromFileName?: (fileName: string) => ts.ScriptKind
+    }
+  ).getScriptKindFromFileName
+  return tsm.createSourceFile(
+    fileName,
+    text,
+    program?.getCompilerOptions().target ?? tsm.ScriptTarget.Latest,
+    true,
+    typeof getScriptKindFromFileName === "function"
+      ? getScriptKindFromFileName(fileName)
+      : tsm.ScriptKind.TSX,
+  )
+}
+
 /** The innermost AST node whose span contains `position`. */
 function innermostNodeAt(
   tsm: typeof ts,
@@ -70,10 +244,15 @@ export function findRoutePathLiteral(
 function routeDefinitionAt(
   tsm: typeof ts,
   ls: ts.LanguageService,
+  host: ts.LanguageServiceHost | undefined,
   fileName: string,
   position: number,
 ): ts.DefinitionInfoAndBoundSpan | undefined {
-  const source = ls.getProgram()?.getSourceFile(fileName)
+  const program = ls.getProgram()
+  const source =
+    programSourceFile(tsm, program, fileName) ??
+    hostSourceFile(tsm, host, program, fileName) ??
+    diskSourceFile(tsm, program, fileName)
   if (source === undefined) return undefined
   const literal = findRoutePathLiteral(tsm, source, position)
   if (literal === undefined) return undefined
@@ -117,12 +296,34 @@ function init(modules: { typescript: typeof ts }): ts.server.PluginModule {
         const member = ls[key]
         writable[key] =
           typeof member === "function"
-            ? (member as (...args: unknown[]) => unknown).bind(ls)
+            ? (...args: unknown[]) => {
+                // TypeScript's public methods generally take the source file name first. Map an
+                // editor's short/long Windows spelling to the Program's own spelling before delegating;
+                // this preserves the real service (and its diagnostics) instead of swallowing a path
+                // mismatch as an empty result.
+                const fileName = args[0]
+                const source =
+                  typeof fileName === "string"
+                    ? programSourceFile(tsm, ls.getProgram(), fileName)
+                    : undefined
+                return (member as (...args: unknown[]) => unknown).apply(ls, [
+                  ...(source === undefined ? args : [source.fileName, ...args.slice(1)]),
+                ])
+              }
             : member
       }
       proxy.getDefinitionAndBoundSpan = (fileName, position) =>
-        routeDefinitionAt(tsm, ls, fileName, position) ??
-        ls.getDefinitionAndBoundSpan(fileName, position)
+        routeDefinitionAt(tsm, ls, info.languageServiceHost, fileName, position) ??
+        (() => {
+          // TypeScript throws when handed an editor spelling that is not the Program's canonical file
+          // name (notably an 8.3 Windows alias). Returning no definition is safer than turning a normal
+          // editor request into an exception; every other language-service method remains delegated
+          // unchanged through the proxy above.
+          const source = programSourceFile(tsm, ls.getProgram(), fileName)
+          return source === undefined
+            ? undefined
+            : ls.getDefinitionAndBoundSpan(source.fileName, position)
+        })()
       return proxy
     },
   }