@marko/language-server 1.0.2 → 1.0.4

package/dist/index.mjs

@@ -1285,20 +1285,35 @@ import {
 import path7 from "path";
 var internalTypesFile = path7.join(__dirname, "marko.internal.d.ts");
 var defaultMarkoTypesFile = path7.join(__dirname, "marko.runtime.d.ts");
-function getProjectTypeLibs(project, ts2, host) {
+function getProjectTypeLibs(rootDir, project, ts2, host) {
   let cached = project.cache.get(getProjectTypeLibs);
   if (cached === void 0) {
-    const { resolvedTypeReferenceDirective } = ts2.resolveTypeReferenceDirective(
+    const markoRunGeneratedTypesFile = path7.join(
+      rootDir,
+      ".marko-run/routes.d.ts"
+    );
+    const resolveFromFile = path7.join(host.getCurrentDirectory(), "_.d.ts");
+    const compilerOptions = host.getCompilationSettings();
+    const { resolvedTypeReferenceDirective: resolvedMarkoTypes } = ts2.resolveTypeReferenceDirective(
       project.translator.runtimeTypes || "marko",
-      path7.join(host.getCurrentDirectory(), "_.d.ts"),
-      host.getCompilationSettings(),
+      resolveFromFile,
+      compilerOptions,
+      host
+    );
+    const { resolvedTypeReferenceDirective: resolvedMarkoRunTypes } = ts2.resolveTypeReferenceDirective(
+      "@marko/run",
+      resolveFromFile,
+      compilerOptions,
       host
     );
-    const markoTypesFile = (resolvedTypeReferenceDirective == null ? void 0 : resolvedTypeReferenceDirective.resolvedFileName) || defaultMarkoTypesFile;
+    const markoTypesFile = (resolvedMarkoTypes == null ? void 0 : resolvedMarkoTypes.resolvedFileName) || defaultMarkoTypesFile;
+    const markoRunTypesFile = resolvedMarkoRunTypes == null ? void 0 : resolvedMarkoRunTypes.resolvedFileName;
     cached = {
       internalTypesFile,
       markoTypesFile,
-      markoTypesCode: host.readFile(markoTypesFile, "utf-8") || ""
+      markoTypesCode: host.readFile(markoTypesFile, "utf-8") || "",
+      markoRunTypesFile,
+      markoRunGeneratedTypesFile: host.fileExists(markoRunGeneratedTypesFile) ? markoRunGeneratedTypesFile : void 0
     };
     project.cache.set(getProjectTypeLibs, cached);
   }
@@ -1339,33 +1354,48 @@ function getComponentFilename(from) {
   const componentBrowserFull = `${nameNoExt}.component-browser.`;
   const componentPartial = isEntry ? "component." : void 0;
   const componentBrowserPartial = isEntry ? "component-browser." : void 0;
-  for (const entry of fs5.readdirSync(dir)) {
+  for (const entry of tryReaddirSync(dir)) {
     if (entry !== from && (isEntry && entry.startsWith(componentBrowserPartial) || entry.startsWith(componentPartial)) || entry.startsWith(componentBrowserFull) || entry.startsWith(componentFull)) {
       return path8.join(dir, entry);
     }
   }
 }
+function tryReaddirSync(dir) {
+  try {
+    return fs5.readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
 
 // src/ts-plugin/host.ts
 var markoExt = ".marko";
 var markoExtReg = /\.marko$/;
 var modulePartsReg = /^((?:@(?:[^/]+)\/)?(?:[^/]+))(.*)$/;
 var fsPathReg = /^(?:[./\\]|[A-Z]:)/i;
-function patch(ts2, scriptLang, cache, host) {
+function patch(ts2, scriptLang, cache, host, ps) {
   var _a, _b, _c;
+  const rootDir = host.getCurrentDirectory();
   const projectTypeLibs = getProjectTypeLibs(
-    getMarkoProject(host.getCurrentDirectory()),
+    rootDir,
+    getMarkoProject(rootDir),
     ts2,
     host
   );
+  const projectTypeLibsFiles = [
+    projectTypeLibs.internalTypesFile,
+    projectTypeLibs.markoTypesFile
+  ];
+  if (projectTypeLibs.markoRunTypesFile) {
+    projectTypeLibsFiles.push(projectTypeLibs.markoRunTypesFile);
+  }
+  if (projectTypeLibs.markoRunGeneratedTypesFile) {
+    projectTypeLibsFiles.push(projectTypeLibs.markoRunGeneratedTypesFile);
+  }
   const isMarkoTSFile = (fileName) => getScriptLang(fileName, ts2, host, scriptLang) === ScriptLang2.ts;
   const getScriptFileNames = host.getScriptFileNames.bind(host);
   host.getScriptFileNames = () => [
-    .../* @__PURE__ */ new Set([
-      ...getScriptFileNames(),
-      projectTypeLibs.internalTypesFile,
-      projectTypeLibs.markoTypesFile
-    ])
+    ...new Set(projectTypeLibsFiles.concat(getScriptFileNames()))
   ];
   const getScriptKind = (_a = host.getScriptKind) == null ? void 0 : _a.bind(host);
   if (getScriptKind) {
@@ -1380,16 +1410,28 @@ function patch(ts2, scriptLang, cache, host) {
       if (!cached) {
         const code = host.readFile(filename, "utf-8") || "";
         const dir = path9.dirname(filename);
-        const markoProject = getMarkoProject(dir);
-        cached = extractScript({
-          ts: ts2,
-          parsed: parse2(code, filename),
-          lookup: markoProject.getLookup(dir),
-          scriptLang: getScriptLang(filename, ts2, host, scriptLang),
-          runtimeTypesCode: projectTypeLibs.markoTypesCode,
-          componentFilename: getComponentFilename(filename)
-        });
-        cached.snapshot = ts2.ScriptSnapshot.fromString(cached.toString());
+        try {
+          const markoProject = getMarkoProject(dir);
+          cached = extractScript({
+            ts: ts2,
+            parsed: parse2(code, filename),
+            lookup: markoProject.getLookup(dir),
+            scriptLang: getScriptLang(filename, ts2, host, scriptLang),
+            runtimeTypesCode: projectTypeLibs.markoTypesCode,
+            componentFilename: getComponentFilename(filename)
+          });
+          cached.snapshot = ts2.ScriptSnapshot.fromString(cached.toString());
+        } catch {
+          cached = { snapshot: ts2.ScriptSnapshot.fromString("") };
+        }
+        ps == null ? void 0 : ps.getOrCreateScriptInfoForNormalizedPath(
+          filename,
+          false,
+          void 0,
+          ts2.ScriptKind.Deferred,
+          false,
+          host
+        );
         cache.set(filename, cached);
       }
       return cached.snapshot;
@@ -1501,7 +1543,7 @@ function patch(ts2, scriptLang, cache, host) {
 }
 
 // src/service/script/index.ts
-var IGNORE_DIAG_REG = /^(?:Expression|Identifier|['"][^\w]['"]) expected.$/;
+var IGNORE_DIAG_REG = /^(?:(?:Expression|Identifier|['"][^\w]['"]) expected|Invalid character)\b/i;
 var extractCache = /* @__PURE__ */ new Map();
 var snapshotCache = /* @__PURE__ */ new Map();
 var insertModuleStatementLocCache = /* @__PURE__ */ new WeakMap();
@@ -1511,6 +1553,34 @@ var optionalModifierReg = /\boptional\b/;
 var deprecatedModifierReg = /\bdeprecated\b/;
 var colorModifierReg = /\bcolor\b/;
 var localInternalsPrefix = "__marko_internal_";
+var requiredTSCompilerOptions = {
+  module: ts.ModuleKind.ESNext,
+  moduleResolution: ts.ModuleResolutionKind.NodeJs,
+  noEmit: true,
+  allowJs: true,
+  composite: false,
+  declaration: false,
+  skipLibCheck: true,
+  isolatedModules: true,
+  resolveJsonModule: true,
+  skipDefaultLibCheck: true,
+  emitDeclarationOnly: false,
+  allowNonTsExtensions: true,
+  emitDecoratorMetadata: false
+};
+var defaultTSConfig = {
+  include: [],
+  compilerOptions: {
+    lib: ["dom", "node", "esnext"]
+  }
+};
+var extraTSCompilerExtensions = [
+  {
+    extension: ".marko",
+    isMixedContent: false,
+    scriptKind: ts.ScriptKind.Deferred
+  }
+];
 var ScriptService = {
   commands: {
     "$/showScriptOutput": async (uri) => {
@@ -1909,7 +1979,12 @@ function processScript(doc, tsProject) {
         parsed,
         lookup,
         scriptLang: getScriptLang(filename, ts, host, markoScriptLang),
-        runtimeTypesCode: (_a = getProjectTypeLibs(markoProject, ts, host)) == null ? void 0 : _a.markoTypesCode,
+        runtimeTypesCode: (_a = getProjectTypeLibs(
+          tsProject.rootDir,
+          markoProject,
+          ts,
+          host
+        )) == null ? void 0 : _a.markoTypesCode,
         componentFilename: getComponentFilename(filename)
       });
     }
@@ -1995,31 +2070,18 @@ function getTSProject(docFsPath) {
     markoProject.cache.set(getTSProject, projectCache);
   }
   const { fileNames, options, projectReferences } = ts.parseJsonConfigFileContent(
-    configPath && ts.readConfigFile(configPath, ts.sys.readFile).config || {
-      compilerOptions: { lib: ["dom", "node", "esnext"] },
-      include: []
-    },
+    configPath && ts.readConfigFile(configPath, ts.sys.readFile).config || defaultTSConfig,
     ts.sys,
     rootDir,
-    void 0,
+    requiredTSCompilerOptions,
     configPath,
     void 0,
-    [
-      {
-        extension: ".marko",
-        isMixedContent: false,
-        scriptKind: ts.ScriptKind.Deferred
-      }
-    ]
+    extraTSCompilerExtensions
   );
+  options.rootDir ??= rootDir;
   const potentialGlobalFiles = new Set(
     fileNames.filter((file) => /\.[cm]?ts$/.test(file))
   );
-  options.rootDir ??= rootDir;
-  options.module = ts.ModuleKind.ESNext;
-  options.moduleResolution = ts.ModuleResolutionKind.NodeJs;
-  options.declaration = false;
-  options.noEmit = options.allowJs = options.skipLibCheck = options.isolatedModules = options.resolveJsonModule = options.skipDefaultLibCheck = options.allowNonTsExtensions = true;
   const tsPkgFile = configPath && ((_a = ts.resolveModuleName("typescript/package.json", configPath, options, ts.sys).resolvedModule) == null ? void 0 : _a.resolvedFileName);
   const defaultLibFile = path10.join(
     tsPkgFile ? path10.join(tsPkgFile, "../lib") : __dirname,
@@ -2114,7 +2176,12 @@ function getTSProject(docFsPath) {
     service: ts.createLanguageService(host),
     markoProject,
     markoScriptLang,
-    markoProjectTypeLibs: getProjectTypeLibs(markoProject, ts, host)
+    markoProjectTypeLibs: getProjectTypeLibs(
+      options.rootDir,
+      markoProject,
+      ts,
+      host
+    )
   };
   projectCache.set(rootDir, tsProject);
   return tsProject;