@danielx/civet 0.11.11 → 0.11.13

package/dist/ts-service/index.mjs

@@ -94,8 +94,8 @@ function remapFileName(fileName, transpilers) {
 }
 
 // source/ts-service/host.civet
-import path3 from "node:path";
-import ts5 from "typescript";
+import path4 from "node:path";
+import ts6 from "typescript";
 import {} from "typescript";
 
 // source/ts-service/config.civet
@@ -208,9 +208,132 @@ function parseTsConfigForCivet(projectPath, transpilers, options = {}) {
   return parsed;
 }
 
+// source/ts-service/resolve.civet
+import path3 from "node:path";
+import ts5 from "typescript";
+function resolveTranspiledModuleName({
+  name,
+  containingFile,
+  compilerOptions,
+  resolutionMode,
+  transpilers,
+  resolveTypeScript,
+  fileExists,
+  directoryExists
+}) {
+  const resolvedModule = (sourcePath, transpiler) => {
+    return {
+      resolvedFileName: sourcePath + transpiler.target,
+      extension: transpiler.target,
+      isExternalLibraryImport: false
+    };
+  };
+  const tsResolved = resolveTypeScript();
+  if (tsResolved.resolvedModule) {
+    return tsResolved;
+  }
+  const moduleResolution = ts5.getEmitModuleResolutionKind(compilerOptions);
+  const isRelative = ts5.isExternalModuleNameRelative(name);
+  let allowImplicitExtension = isRelative && !(resolutionMode === ts5.ModuleKind.ESNext && (moduleResolution === ts5.ModuleResolutionKind.Node16 || moduleResolution === ts5.ModuleResolutionKind.NodeNext));
+  let allowDirectoryIndex = (!isRelative || allowImplicitExtension) && moduleResolution !== ts5.ModuleResolutionKind.Classic;
+  const tryResolveSource = (sourcePath) => {
+    if (fileExists(sourcePath)) {
+      const candidateExtension = getExtensionFromPath(sourcePath);
+      let ref;
+      if (ref = transpilers.get(candidateExtension)) {
+        const candidateTranspiler = ref;
+        return resolvedModule(sourcePath, candidateTranspiler);
+      }
+    }
+    if (allowImplicitExtension) {
+      for (const [ext, t] of transpilers) {
+        const candidate = sourcePath + ext;
+        if (fileExists(candidate)) {
+          return resolvedModule(candidate, t);
+        }
+      }
+    }
+    if (allowDirectoryIndex && directoryExists(sourcePath)) {
+      for (const [_, t] of transpilers) {
+        const index = path3.join(sourcePath, "index" + t.extension);
+        if (fileExists(index)) {
+          return resolvedModule(index, t);
+        }
+      }
+    }
+    return;
+  };
+  if (!isRelative) {
+    let ref1;
+    if (ref1 = compilerOptions.paths) {
+      const paths = ref1;
+      let ref2;
+      if (ref2 = compilerOptions.baseUrl ?? compilerOptions.pathsBasePath) {
+        const pathsBase = ref2;
+        let bestPrefixLength = -1;
+        let bestCandidates = [];
+        for (const [pattern, replacements] of Object.entries(paths)) {
+          const starIndex = pattern.indexOf("*");
+          let matched;
+          let prefixLength;
+          if (starIndex >= 0) {
+            const prefix = pattern.slice(0, starIndex);
+            const suffix = pattern.slice(starIndex + 1);
+            if (name.startsWith(prefix) && name.endsWith(suffix) && name.length >= prefix.length + suffix.length) {
+              matched = name.slice(prefix.length, name.length - suffix.length);
+              prefixLength = prefix.length;
+            } else {
+              continue;
+            }
+          } else {
+            if (!(name === pattern)) {
+              continue;
+            }
+            matched = "";
+            prefixLength = pattern.length;
+          }
+          if (prefixLength < bestPrefixLength) {
+            continue;
+          }
+          if (prefixLength > bestPrefixLength) {
+            bestPrefixLength = prefixLength;
+            bestCandidates = [];
+          }
+          for (const replacement of replacements) {
+            let ref3;
+            if (starIndex >= 0) {
+              ref3 = replacement.replace("*", () => matched);
+            } else {
+              ref3 = replacement;
+            }
+            ;
+            const target = ref3;
+            bestCandidates.push(path3.resolve(pathsBase, target));
+          }
+        }
+        for (const candidate of bestCandidates) {
+          let ref4;
+          if (ref4 = tryResolveSource(candidate)) {
+            const resolved2 = ref4;
+            return { resolvedModule: resolved2 };
+          }
+        }
+      }
+    }
+  }
+  if (!isRelative) {
+    return tsResolved;
+  }
+  const relativeSourcePath = path3.resolve(path3.dirname(containingFile), name);
+  const resolved = tryResolveSource(relativeSourcePath);
+  if (resolved) {
+    return { resolvedModule: resolved };
+  }
+  return tsResolved;
+}
+
 // source/ts-service/host.civet
 import assert from "node:assert";
-var { isExternalModuleNameRelative } = ts5;
 function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, docFactory, _logger = console, libDir) {
   const { rootDir } = compilationSettings;
   assert(rootDir, "TSHost requires a rootDir in compilationSettings");
@@ -223,7 +346,7 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
   const pathMap = /* @__PURE__ */ new Map();
   const snapshotMap = /* @__PURE__ */ new Map();
   let projectVersion = 0;
-  const resolutionCache = ts5.createModuleResolutionCache(rootDir, (fileName) => fileName, compilationSettings);
+  const resolutionCache = ts6.createModuleResolutionCache(rootDir, (fileName) => fileName, compilationSettings);
   const baseReadFile = baseHost.readFile.bind(baseHost);
   const baseFileExists = baseHost.fileExists.bind(baseHost);
   const baseDirectoryExists = baseHost.directoryExists?.bind(baseHost) ?? (() => false);
@@ -232,7 +355,7 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
     /** Mogrifies transpilable extensions inside `package.json#imports` on read. */
     readFile(filename) {
       const contents = getPathSource(filename);
-      if (contents && path3.basename(filename) === "package.json") {
+      if (contents && path4.basename(filename) === "package.json") {
         return mogrifyPackageJsonImports(contents, transpilers);
       }
       return contents;
@@ -247,7 +370,7 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
      */
     getDefaultLibFileName(options) {
       if (libDir) {
-        return path3.join(libDir, ts5.getDefaultLibFileName(options));
+        return path4.join(libDir, ts6.getDefaultLibFileName(options));
       }
       return baseHost.getDefaultLibFileName(options);
     },
@@ -255,7 +378,7 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
       if (libDir) {
         return libDir;
       }
-      return baseHost.getDefaultLibLocation?.() ?? path3.dirname(baseHost.getDefaultLibFileName(compilationSettings));
+      return baseHost.getDefaultLibLocation?.() ?? path4.dirname(baseHost.getDefaultLibFileName(compilationSettings));
     },
     getModuleResolutionCache() {
       return resolutionCache;
@@ -267,128 +390,43 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
      * synthetic `<src>.<target>` so subsequent `getScriptSnapshot` calls
      * hit the transpiler.
      */
-    resolveModuleNames(moduleNames, containingFile, _reusedNames, _redirectedReference, compilerOptions, _containingSourceFile) {
-      return moduleNames.map((name) => {
-        const { resolvedModule } = ts5.resolveModuleName(name, containingFile, compilerOptions, self, resolutionCache);
-        if (resolvedModule) {
-          return resolvedModule;
-        }
-        const extension = getExtensionFromPath(name);
-        let transpiler = transpilers.get(extension);
-        if (transpiler || !extension) {
-          const exists = transpiler ? pathExists : baseDirectoryExists;
-          const resolvedModule2 = (resolved2) => {
-            if (!transpiler) {
-              for (const [_, t] of transpilers) {
-                const index = path3.join(resolved2, "index" + t.extension);
-                if (pathExists(index)) {
-                  transpiler = t;
-                  resolved2 = index;
-                  break;
-                }
-              }
-              if (!transpiler) {
-                return;
-              }
-            }
-            const { target } = transpiler;
-            return {
-              resolvedFileName: resolved2 + target,
-              extension: target,
-              isExternalLibraryImport: false
-            };
-          };
-          const { paths, pathsBasePath } = compilationSettings;
-          const baseUrl = compilationSettings.baseUrl;
-          if (!isExternalModuleNameRelative(name)) {
-            if (paths) {
-              const pathsBase = baseUrl ?? pathsBasePath;
-              let best = "";
-              let bestPrefix = "";
-              for (const [pattern, replacements] of Object.entries(paths)) {
-                if (pattern.endsWith("*")) {
-                  const prefix = pattern.slice(0, -1);
-                  if (name.startsWith(prefix)) {
-                    for (const replacement of replacements) {
-                      const resolved2 = path3.resolve(
-                        pathsBase,
-                        replacement.replace("*", name.slice(prefix.length))
-                      );
-                      if (exists(resolved2) && prefix.length > bestPrefix.length) {
-                        best = resolved2;
-                        bestPrefix = prefix;
-                      }
-                    }
-                  }
-                } else if (name === pattern) {
-                  for (const replacement of replacements) {
-                    const resolved2 = path3.resolve(pathsBase, replacement);
-                    if (exists(resolved2) && pattern.length > bestPrefix.length) {
-                      best = resolved2;
-                      bestPrefix = pattern;
-                    }
-                  }
-                }
-              }
-              if (best) {
-                return resolvedModule2(best);
-              }
-            }
-            if (baseUrl) {
-              const resolved2 = path3.resolve(baseUrl, name);
-              if (exists(resolved2)) {
-                return resolvedModule2(resolved2);
-              }
-            }
-          } else {
-          }
-          const resolved = path3.resolve(path3.dirname(containingFile), name);
-          if (exists(resolved)) {
-            return resolvedModule2(resolved);
-          }
-        }
-        return void 0;
+    resolveModuleNames(moduleNames, containingFile, _reusedNames, redirectedReference, compilerOptions, containingSourceFile) {
+      return moduleNames.map((name, index) => {
+        const resolutionMode = containingSourceFile && ts6.getModeForResolutionAtIndex(containingSourceFile, index, compilerOptions);
+        return resolveTranspiledModuleName({
+          name,
+          containingFile,
+          compilerOptions,
+          resolutionMode,
+          transpilers,
+          resolveTypeScript: () => {
+            return ts6.resolveModuleName(name, containingFile, compilerOptions, self, resolutionCache, redirectedReference, resolutionMode);
+          },
+          fileExists: pathExists,
+          directoryExists: baseDirectoryExists
+        }).resolvedModule;
       });
     },
-    resolveModuleNameLiterals(literals, containingFile, _redirectedReference, compilerOptions) {
-      return literals.map((literal) => {
+    resolveModuleNameLiterals(literals, containingFile, redirectedReference, compilerOptions, containingSourceFile) {
+      return literals.map((literal, index) => {
         const name = literal.text;
-        for (const [ext, t] of transpilers) {
-          if (name.endsWith(ext)) {
-            const resolved = path3.resolve(path3.dirname(containingFile), name);
-            if (pathExists(resolved)) {
-              return {
-                resolvedModule: {
-                  resolvedFileName: resolved + t.target,
-                  extension: t.target,
-                  isExternalLibraryImport: false
-                }
-              };
-            }
-          }
-        }
-        if (!getExtensionFromPath(name)) {
-          const resolved = path3.resolve(path3.dirname(containingFile), name);
-          if (baseDirectoryExists(resolved)) {
-            for (const [_, t] of transpilers) {
-              const index = path3.join(resolved, "index" + t.extension);
-              if (pathExists(index)) {
-                return {
-                  resolvedModule: {
-                    resolvedFileName: index + t.target,
-                    extension: t.target,
-                    isExternalLibraryImport: false
-                  }
-                };
-              }
-            }
-          }
-        }
-        return { resolvedModule: ts5.resolveModuleName(name, containingFile, compilerOptions, self, resolutionCache).resolvedModule };
+        const resolutionMode = containingSourceFile && ts6.getModeForResolutionAtIndex(containingSourceFile, index, compilerOptions);
+        return resolveTranspiledModuleName({
+          name,
+          containingFile,
+          compilerOptions,
+          resolutionMode,
+          transpilers,
+          resolveTypeScript: () => {
+            return ts6.resolveModuleName(name, containingFile, compilerOptions, self, resolutionCache, redirectedReference, resolutionMode);
+          },
+          fileExists: pathExists,
+          directoryExists: baseDirectoryExists
+        });
       });
     },
     addOrUpdateDocument(doc) {
-      const rawPath = path3.normalize(docFactory.uriToPath(doc.uri));
+      const rawPath = path4.normalize(docFactory.uriToPath(doc.uri));
       const p = getCanonicalFileName(rawPath);
       snapshotMap.delete(p);
       projectVersion++;
@@ -499,7 +537,7 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
     return void 0;
   }
   function getTranspiledPath(p) {
-    p = path3.normalize(p);
+    p = path4.normalize(p);
     const extension = getExtensionFromPath(p);
     const transpiler = transpilers.get(extension);
     if (transpiler) {
@@ -511,7 +549,7 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
     return getCanonicalFileName(getTranspiledPath(p));
   }
   function getOrCreatePathSnapshot(p) {
-    const rawPath = path3.normalize(p);
+    const rawPath = path4.normalize(p);
     p = getCanonicalFileName(rawPath);
     let snapshot = snapshotMap.get(p);
     if (snapshot) {
@@ -593,7 +631,7 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
     return transpiledCode;
   }
   function initTranspiledDoc(p) {
-    const scriptPath = path3.normalize(p);
+    const scriptPath = path4.normalize(p);
     p = getCanonicalFileName(scriptPath);
     const uri = docFactory.pathToUri(scriptPath);
     const transpiledDoc = docFactory.create(uri, "none", -1, "");
@@ -604,16 +642,16 @@ function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, do
 }
 
 // source/ts-service/service.civet
-import path4 from "node:path";
-import ts6 from "typescript";
+import path5 from "node:path";
+import ts7 from "typescript";
 import {} from "typescript";
 var {
   createCompilerHost,
   createLanguageService
-} = ts6;
+} = ts7;
 function TSService(projectPath, options) {
   const { plugins = [], docFactory, libDir, discoverProjectFiles = true, extraCompilerOptions } = options;
-  const system = options.system ?? ts6.sys;
+  const system = options.system ?? ts7.sys;
   const logger = options.logger ?? console;
   const transpilers = buildTranspilers(plugins);
   function registerPlugin(plugin) {
@@ -638,7 +676,7 @@ function TSService(projectPath, options) {
   const host = TSHost(hostOptions, parsedConfig.fileNames, baseHost, transpilers, docFactory, logger, libDir);
   const service = createLanguageService(host);
   const loadPlugins = async function() {
-    const civetFolder = path4.join(projectPath, "./.civet/");
+    const civetFolder = path5.join(projectPath, "./.civet/");
     let civetFiles;
     try {
       civetFiles = system.readDirectory(civetFolder);
@@ -675,7 +713,7 @@ function TSService(projectPath, options) {
   });
 }
 function createBaseHost(options, system) {
-  if (system === ts6.sys) {
+  if (system === ts7.sys) {
     return createCompilerHost(options);
   }
   const getCanonicalFileName2 = (fileName) => {
@@ -689,10 +727,10 @@ function createBaseHost(options, system) {
       if (!(sourceText != null)) {
         return;
       }
-      return ts6.createSourceFile(fileName, sourceText, languageVersion);
+      return ts7.createSourceFile(fileName, sourceText, languageVersion);
     },
     getDefaultLibFileName(options2) {
-      return path4.join("/typescript/lib", ts6.getDefaultLibFileName(options2));
+      return path5.join("/typescript/lib", ts7.getDefaultLibFileName(options2));
     },
     writeFile(fileName, content) {
       return system.writeFile?.(fileName, content);
@@ -700,8 +738,8 @@ function createBaseHost(options, system) {
     getCurrentDirectory() {
       return system.getCurrentDirectory();
     },
-    getDirectories(path7) {
-      return system.getDirectories?.(path7) ?? [];
+    getDirectories(path8) {
+      return system.getDirectories?.(path8) ?? [];
     },
     fileExists(fileName) {
       return system.fileExists(fileName);
@@ -716,14 +754,17 @@ function createBaseHost(options, system) {
     getNewLine() {
       return system.newLine;
     },
-    directoryExists(path7) {
-      return system.directoryExists?.(path7) ?? false;
+    directoryExists(path8) {
+      if (!(system.directoryExists != null)) {
+        return false;
+      }
+      return system.directoryExists(path8);
     },
-    readDirectory(path7, extensions, excludes, includes, depth) {
-      return system.readDirectory(path7, extensions, excludes, includes, depth);
+    readDirectory(path8, extensions, excludes, includes, depth) {
+      return system.readDirectory(path8, extensions, excludes, includes, depth);
     },
-    realpath(path7) {
-      return system.realpath ? system.realpath(path7) : path7;
+    realpath(path8) {
+      return system.realpath ? system.realpath(path8) : path8;
     }
   };
 }
@@ -769,7 +810,7 @@ import {} from "typescript";
 // source/cache.civet
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 function hashParts(parts) {
   const hash = crypto.createHash("sha1");
   for (const part of parts) {
@@ -793,7 +834,7 @@ function stableStringify(value) {
   });
 }
 function makeCacheKey(input) {
-  const resolved = path5.resolve(input.sourcePath).replace(/\\/g, "/");
+  const resolved = path6.resolve(input.sourcePath).replace(/\\/g, "/");
   return hashParts([
     input.source,
     input.compilerName,
@@ -823,7 +864,7 @@ function createDiskCache(dir) {
   }
   return {
     get(key) {
-      const target = path5.join(dir, key);
+      const target = path6.join(dir, key);
       try {
         const content = fs.readFileSync(target, "utf8");
         try {
@@ -837,7 +878,7 @@ function createDiskCache(dir) {
       }
     },
     set(key, value) {
-      const target = path5.join(dir, key);
+      const target = path6.join(dir, key);
       try {
         const tmp = `${target}.tmp.${process.pid}`;
         fs.writeFileSync(tmp, value);
@@ -1063,19 +1104,18 @@ function makeHeraPlugin(options = {}) {
 }
 
 // source/ts-service/typecheck.civet
-import ts7 from "typescript";
+import ts8 from "typescript";
 import * as fs2 from "fs";
-import * as path6 from "path";
+import * as path7 from "path";
 function makeIncrementalTypecheckProgram(projectPath, options) {
   const transpilers = buildTranspilers(options.plugins);
-  const extraExtensions = Array.from(transpilers.keys());
   const parsed = parseTsConfigForCivet(projectPath, transpilers, { tsConfig: options.tsConfig });
   const compilerOptions = {
     ...parsed.options,
     ...options.extraCompilerOptions
   };
-  compilerOptions.jsx ??= ts7.JsxEmit.Preserve;
-  const baseHost = ts7.createIncrementalCompilerHost(compilerOptions);
+  compilerOptions.jsx ??= ts8.JsxEmit.Preserve;
+  const baseHost = ts8.createIncrementalCompilerHost(compilerOptions);
   const fileMetaData = /* @__PURE__ */ new Map();
   const hashText = (text) => {
     return baseHost.createHash?.(text) ?? text.length.toString();
@@ -1119,7 +1159,7 @@ function makeIncrementalTypecheckProgram(projectPath, options) {
         parseErrors: result.errors,
         fatal: false
       });
-      const sf2 = ts7.createSourceFile(fileName, result.code, langVersion, true);
+      const sf2 = ts8.createSourceFile(fileName, result.code, langVersion, true);
       sf2.version = hashText(result.code);
       return sf2;
     }
@@ -1130,6 +1170,7 @@ function makeIncrementalTypecheckProgram(projectPath, options) {
     return sf;
   };
   const origFileExists = baseHost.fileExists.bind(baseHost);
+  const origDirectoryExists = baseHost.directoryExists?.bind(baseHost) ?? (() => false);
   baseHost.fileExists = (fileName) => {
     const exts = getTranspiledExtensionsFromPath(fileName);
     if (exts) {
@@ -1143,43 +1184,56 @@ function makeIncrementalTypecheckProgram(projectPath, options) {
   const origReadFile = baseHost.readFile.bind(baseHost);
   baseHost.readFile = (fileName) => {
     const contents = origReadFile(fileName);
-    if (contents && path6.basename(fileName) === "package.json") {
+    if (contents && path7.basename(fileName) === "package.json") {
       return mogrifyPackageJsonImports(contents, transpilers);
     }
     return contents;
   };
-  baseHost.resolveModuleNameLiterals = (literals, containingFile, _redirected, opts) => {
-    return literals.map((lit) => {
+  baseHost.resolveModuleNameLiterals = (literals, containingFile, redirectedReference, opts, containingSourceFile) => {
+    return literals.map((lit, index) => {
       const name = lit.text;
-      for (const ext of extraExtensions) {
-        if (name.endsWith(ext)) {
-          const t = transpilers.get(ext);
-          const containingDir = path6.dirname(containingFile);
-          const resolved = path6.resolve(containingDir, name);
-          if (origFileExists(resolved)) {
-            return {
-              resolvedModule: {
-                resolvedFileName: resolved + t.target,
-                extension: t.target,
-                isExternalLibraryImport: false
-              }
-            };
-          }
-        }
-      }
-      return { resolvedModule: ts7.resolveModuleName(name, containingFile, opts, baseHost).resolvedModule };
+      const resolutionMode = containingSourceFile && ts8.getModeForResolutionAtIndex(containingSourceFile, index, opts);
+      return resolveTranspiledModuleName({
+        name,
+        containingFile,
+        compilerOptions: opts,
+        resolutionMode,
+        transpilers,
+        resolveTypeScript: () => {
+          return ts8.resolveModuleName(name, containingFile, opts, baseHost, void 0, redirectedReference, resolutionMode);
+        },
+        fileExists: origFileExists,
+        directoryExists: origDirectoryExists
+      });
+    });
+  };
+  baseHost.resolveModuleNames = (moduleNames, containingFile, _reusedNames, redirectedReference, opts, containingSourceFile) => {
+    return moduleNames.map((name, index) => {
+      const resolutionMode = containingSourceFile && ts8.getModeForResolutionAtIndex(containingSourceFile, index, opts);
+      return resolveTranspiledModuleName({
+        name,
+        containingFile,
+        compilerOptions: opts,
+        resolutionMode,
+        transpilers,
+        resolveTypeScript: () => {
+          return ts8.resolveModuleName(name, containingFile, opts, baseHost, void 0, redirectedReference, resolutionMode);
+        },
+        fileExists: origFileExists,
+        directoryExists: origDirectoryExists
+      }).resolvedModule;
     });
   };
   const programOptions = {
     rootNames: parsed.fileNames,
     options: compilerOptions,
     host: baseHost,
-    configFileParsingDiagnostics: ts7.getConfigFileParsingDiagnostics(parsed)
+    configFileParsingDiagnostics: ts8.getConfigFileParsingDiagnostics(parsed)
   };
   if (parsed.projectReferences) {
     programOptions.projectReferences = parsed.projectReferences;
   }
-  const builder = ts7.createIncrementalProgram(programOptions);
+  const builder = ts8.createIncrementalProgram(programOptions);
   return {
     builder,
     host: baseHost,