fix

Author: ota-meshi

src/context/index.ts

@@ -1,5 +1,3 @@
-import fs from "fs";
-import path from "path";
 import type {
   Comment,
   Locations,
@@ -15,19 +13,13 @@ import type ESTree from "estree";
 import type * as SvAST from "../parser/svelte-ast-types";
 import { ScriptLetContext } from "./script-let";
 import { LetDirectiveCollections } from "./let-directive-collection";
-import { getParserForLang } from "../parser/resolve-parser";
 import type { AttributeToken } from "../parser/html";
 import { parseAttributes } from "../parser/html";
-import {
-  isTSESLintParserObject,
-  maybeTSESLintParserObject,
-} from "../parser/parser-object";
 import { sortedLastIndex } from "../utils";
-
-const TS_PARSER_NAMES = [
-  "@typescript-eslint/parser",
-  "typescript-eslint-parser-for-extra-files",
-];
+import {
+  isTypeScript,
+  type NormalizedParserOptions,
+} from "../parser/parser-options";
 
 export class ScriptsSourceCode {
   private raw: string;
@@ -116,7 +108,7 @@ export type ContextSourceCode = {
 export class Context {
   public readonly code: string;
 
-  public readonly parserOptions: any;
+  public readonly parserOptions: NormalizedParserOptions;
 
   // ----- Source Code ------
   public readonly sourceCode: ContextSourceCode;
@@ -155,7 +147,7 @@ export class Context {
 
   private readonly blocks: Block[] = [];
 
-  public constructor(code: string, parserOptions: any) {
+  public constructor(code: string, parserOptions: NormalizedParserOptions) {
     this.code = code;
     this.parserOptions = parserOptions;
     this.locs = new LinesAndColumns(code);
@@ -287,44 +279,7 @@ export class Context {
       return this.state.isTypeScript;
     }
     const lang = this.sourceCode.scripts.attrs.lang;
-    if (!lang) {
-      return (this.state.isTypeScript = false);
-    }
-    const parserValue = getParserForLang(
-      this.sourceCode.scripts.attrs,
-      this.parserOptions?.parser,
-    );
-    if (typeof parserValue !== "string") {
-      return (this.state.isTypeScript =
-        maybeTSESLintParserObject(parserValue) ||
-        isTSESLintParserObject(parserValue));
-    }
-    const parserName = parserValue;
-    if (TS_PARSER_NAMES.includes(parserName)) {
-      return (this.state.isTypeScript = true);
-    }
-    if (TS_PARSER_NAMES.some((nm) => parserName.includes(nm))) {
-      let targetPath = parserName;
-      while (targetPath) {
-        const pkgPath = path.join(targetPath, "package.json");
-        if (fs.existsSync(pkgPath)) {
-          try {
-            return (this.state.isTypeScript = TS_PARSER_NAMES.includes(
-              JSON.parse(fs.readFileSync(pkgPath, "utf-8"))?.name,
-            ));
-          } catch {
-            return (this.state.isTypeScript = false);
-          }
-        }
-        const parent = path.dirname(targetPath);
-        if (targetPath === parent) {
-          break;
-        }
-        targetPath = parent;
-      }
-    }
-
-    return (this.state.isTypeScript = false);
+    return (this.state.isTypeScript = isTypeScript(this.parserOptions, lang));
   }
 
   public stripScriptCode(start: number, end: number): void {

src/parser/analyze-scope.ts

@@ -5,12 +5,13 @@ import { getFallbackKeys } from "../traverse";
 import type { SvelteReactiveStatement, SvelteScriptElement } from "../ast";
 import { addReference, addVariable } from "../scope";
 import { addElementToSortedArray } from "../utils";
+import type { NormalizedParserOptions } from "./parser-options";
 /**
  * Analyze scope
  */
 export function analyzeScope(
   node: ESTree.Node,
-  parserOptions: any = {},
+  parserOptions: NormalizedParserOptions,
 ): ScopeManager {
   const ecmaVersion = parserOptions.ecmaVersion || 2020;
   const ecmaFeatures = parserOptions.ecmaFeatures || {};

src/parser/globals.ts

@@ -1,10 +1,6 @@
 import { svelteVersion } from "./svelte-version";
 
-const globalsForSvelte4: Readonly<string[]> = [
-  "$$slots",
-  "$$props",
-  "$$restProps",
-] as const;
+const globalsForSvelte4 = ["$$slots", "$$props", "$$restProps"] as const;
 export const globalsForRunes = [
   "$state",
   "$derived",

src/parser/index.ts

@@ -20,7 +20,7 @@ import {
   analyzeStoreScope,
 } from "./analyze-scope";
 import { ParseError } from "../errors";
-import { parseTypeScript } from "./typescript";
+import { parseTypeScript, parseTypeScriptInSvelte } from "./typescript";
 import { addReference } from "../scope";
 import {
   parseStyleContext,
@@ -34,6 +34,8 @@ import {
 } from "./style-context";
 import { globals, globalsForSvelteScript } from "./globals";
 import { svelteVersion } from "./svelte-version";
+import type { NormalizedParserOptions } from "./parser-options";
+import { isTypeScript, normalizeParserOptions } from "./parser-options";
 
 export {
   StyleContext,
@@ -111,7 +113,7 @@ function parseAsSvelte(
 
   const scripts = ctx.sourceCode.scripts;
   const resultScript = ctx.isTypeScript()
-    ? parseTypeScript(
+    ? parseTypeScriptInSvelte(
         scripts.getCurrentVirtualCodeInfo(),
         scripts.attrs,
         parserOptions,
@@ -231,8 +233,10 @@ function parseAsScript(
   code: string,
   parserOptions: NormalizedParserOptions,
 ): ParseResult {
-  const lang = parserOptions.filePath?.split(".").pop() || "js";
-  const resultScript = parseScript(code, { lang }, parserOptions);
+  const lang = parserOptions.filePath?.split(".").pop();
+  const resultScript = isTypeScript(parserOptions, lang)
+    ? parseTypeScript(code, { lang }, parserOptions)
+    : parseScript(code, { lang }, parserOptions);
 
   // Add $$xxx variable
   const globalScope = resultScript.scopeManager!.globalScope;
@@ -263,41 +267,6 @@ function parseAsScript(
   return resultScript as any;
 }
 
-type NormalizedParserOptions = {
-  ecmaVersion: number | "latest";
-  sourceType: "module" | "script";
-  loc: boolean;
-  range: boolean;
-  raw: boolean;
-  tokens: boolean;
-  comment: boolean;
-  eslintVisitorKeys: boolean;
-  eslintScopeManager: boolean;
-  filePath?: string;
-};
-
-/** Normalize parserOptions */
-function normalizeParserOptions(options: any): NormalizedParserOptions {
-  const parserOptions = {
-    ecmaVersion: 2020,
-    sourceType: "module",
-    loc: true,
-    range: true,
-    raw: true,
-    tokens: true,
-    comment: true,
-    eslintVisitorKeys: true,
-    eslintScopeManager: true,
-    ...(options || {}),
-  };
-  parserOptions.sourceType = "module";
-  if (parserOptions.ecmaVersion <= 5 || parserOptions.ecmaVersion == null) {
-    parserOptions.ecmaVersion = 2015;
-  }
-
-  return parserOptions;
-}
-
 /** Extract tokens */
 function extractTokens(ctx: Context) {
   const useRanges = sortNodes([...ctx.tokens, ...ctx.comments]).map(

src/parser/parser-options.ts

@@ -0,0 +1,99 @@
+import fs from "fs";
+import path from "path";
+import {
+  isTSESLintParserObject,
+  maybeTSESLintParserObject,
+} from "./parser-object";
+import { getParserForLang, type UserOptionParser } from "./resolve-parser";
+
+export type NormalizedParserOptions = {
+  parser?: UserOptionParser;
+  project?: string | string[] | null;
+
+  ecmaVersion: number | "latest";
+  sourceType: "module" | "script";
+  ecmaFeatures?: {
+    globalReturn?: boolean | undefined;
+    impliedStrict?: boolean | undefined;
+    jsx?: boolean | undefined;
+    experimentalObjectRestSpread?: boolean | undefined;
+    [key: string]: any;
+  };
+  loc: boolean;
+  range: boolean;
+  raw: boolean;
+  tokens: boolean;
+  comment: boolean;
+  eslintVisitorKeys: boolean;
+  eslintScopeManager: boolean;
+  filePath?: string;
+};
+
+/** Normalize parserOptions */
+export function normalizeParserOptions(options: any): NormalizedParserOptions {
+  const parserOptions = {
+    ecmaVersion: 2020,
+    sourceType: "module",
+    loc: true,
+    range: true,
+    raw: true,
+    tokens: true,
+    comment: true,
+    eslintVisitorKeys: true,
+    eslintScopeManager: true,
+    ...(options || {}),
+  };
+  parserOptions.sourceType = "module";
+  if (parserOptions.ecmaVersion <= 5 || parserOptions.ecmaVersion == null) {
+    parserOptions.ecmaVersion = 2015;
+  }
+
+  return parserOptions;
+}
+
+const TS_PARSER_NAMES = [
+  "@typescript-eslint/parser",
+  "typescript-eslint-parser-for-extra-files",
+];
+
+export function isTypeScript(
+  parserOptions: NormalizedParserOptions,
+  lang: string | undefined,
+): boolean {
+  if (!lang) {
+    return false;
+  }
+  const parserValue = getParserForLang(lang, parserOptions?.parser);
+  if (typeof parserValue !== "string") {
+    return (
+      maybeTSESLintParserObject(parserValue) ||
+      isTSESLintParserObject(parserValue)
+    );
+  }
+  const parserName = parserValue;
+  if (TS_PARSER_NAMES.includes(parserName)) {
+    return true;
+  }
+  if (TS_PARSER_NAMES.some((nm) => parserName.includes(nm))) {
+    let targetPath = parserName;
+    while (targetPath) {
+      const pkgPath = path.join(targetPath, "package.json");
+      if (fs.existsSync(pkgPath)) {
+        try {
+          return TS_PARSER_NAMES.includes(
+            JSON.parse(fs.readFileSync(pkgPath, "utf-8"))?.name,
+          );
+        } catch {
+          return false;
+        }
+      }
+      const parent = path.dirname(targetPath);
+      if (targetPath === parent) {
+        break;
+      }
+      targetPath = parent;
+    }
+  }
+
+  return false;
+}

src/parser/resolve-parser.ts

@@ -2,23 +2,23 @@ import { getEspree } from "./espree";
 import type { ParserObject } from "./parser-object";
 import { isParserObject } from "./parser-object";
 
-type UserOptionParser =
+export type UserOptionParser =
   | string
   | ParserObject
   | Record<string, string | ParserObject | undefined>
   | undefined;
 
 /** Get parser for script lang */
 export function getParserForLang(
-  attrs: Record<string, string | undefined>,
+  lang: string | undefined | null,
   parser: UserOptionParser,
 ): string | ParserObject {
   if (parser) {
     if (typeof parser === "string" || isParserObject(parser)) {
       return parser;
     }
     if (typeof parser === "object") {
-      const value = parser[attrs.lang || "js"];
+      const value = parser[lang || "js"];
       if (typeof value === "string" || isParserObject(value)) {
         return value;
       }
@@ -32,7 +32,7 @@ export function getParser(
   attrs: Record<string, string | undefined>,
   parser: UserOptionParser,
 ): ParserObject {
-  const parserValue = getParserForLang(attrs, parser);
+  const parserValue = getParserForLang(attrs.lang, parser);
   if (isParserObject(parserValue)) {
     return parserValue;
   }

src/parser/script.ts

@@ -3,14 +3,15 @@ import { analyzeScope } from "./analyze-scope";
 import { traverseNodes } from "../traverse";
 import { getParser } from "./resolve-parser";
 import { isEnhancedParserObject } from "./parser-object";
+import type { NormalizedParserOptions } from "./parser-options";
 
 /**
  * Parse for <script>
  */
 export function parseScriptInSvelte(
   code: string,
   attrs: Record<string, string | undefined>,
-  parserOptions: any = {},
+  parserOptions: NormalizedParserOptions,
 ): ESLintExtendedProgram {
   const result = parseScript(code, attrs, parserOptions);
 
@@ -39,7 +40,7 @@ export function parseScriptInSvelte(
 export function parseScript(
   code: string,
   attrs: Record<string, string | undefined>,
-  parserOptions: any = {},
+  parserOptions: NormalizedParserOptions,
 ): ESLintExtendedProgram {
   const result = parseScriptWithoutAnalyzeScopeFromVCode(
     code,
@@ -61,7 +62,7 @@ export function parseScript(
 export function parseScriptWithoutAnalyzeScope(
   code: string,
   attrs: Record<string, string | undefined>,
-  options: any,
+  options: NormalizedParserOptions,
 ): ESLintExtendedProgram {
   const parser = getParser(attrs, options.parser);
 
@@ -81,7 +82,7 @@ export function parseScriptWithoutAnalyzeScope(
 function parseScriptWithoutAnalyzeScopeFromVCode(
   code: string,
   attrs: Record<string, string | undefined>,
-  options: any,
+  options: NormalizedParserOptions,
 ): ESLintExtendedProgram {
   const result = parseScriptWithoutAnalyzeScope(code, attrs, options);
   result._virtualScriptCode = code;

src/parser/template.ts

@@ -6,14 +6,15 @@ import { convertSvelteRoot } from "./converts/index";
 import { sortNodes } from "./sort";
 import type { SvelteProgram } from "../ast";
 import { ParseError } from "..";
+import type { NormalizedParserOptions } from "./parser-options";
 
 /**
  * Parse for template
  */
 export function parseTemplate(
   code: string,
   ctx: Context,
-  parserOptions: any = {},
+  parserOptions: NormalizedParserOptions,
 ): {
   ast: SvelteProgram;
   svelteAst: SvAST.Ast;