svelte.ts

Analyze a Svelte module using checker-backed analysis.

Requires the svelte2tsx virtual output to be included in the TypeScript program (via createAnalysisProgram({ virtualFiles })). Provides full type resolution for:

• Imported prop types (let {x}: ImportedProps = $props())
• <script module> exports (constants, types, re-exports)
• Star exports and re-exports from Svelte files

Extract @module comment from HTML comments in Svelte source.

Scans all <!-- ... --> comments for one containing @module at the start of a line. This allows @component and @module to coexist as separate HTML comments. Works for template-only components.

Extract the content of the module <script> tag from Svelte source.

Counterpart of extractScriptContent: matches only module scripts, so the two partition a source's script tags consistently.

Extract the content of the main <script> tag from Svelte source — commented-out scripts skipped, module scripts (<script module>, <script context="module">) excluded.

Extract structured parameters from a Snippet<[...]> type.

Snippet is an interface, so type arguments are on TypeReference (accessed via checker.getTypeArguments), not on aliasTypeArguments (which is only for type aliases).

Returns full ParameterJson input objects (with optional and rest always set) for runtime consistency with extractSignatureParameters in typescript-extract-shared.ts. Optional tuple elements are widened to include undefined — under exactOptionalPropertyTypes too, unlike properties — so the element type is stripped unconditionally via getTypeSignature and optional: true carries it alone. Rest elements report like rest signature parameters — rest: true with the printed array form (...rest: B[] carries B[]) — and a variadic spread (...T) carries the spread type itself, mirroring the structured typeInfo tuple (buildTuple). Callers pass the bare Snippet<...> TypeReference — a union wrapping it (optional widening, | null) reports no type arguments.

Extract module-level comment from Svelte script content.

Parses the script content as TypeScript and delegates to extractModuleComment for the shared @module tag detection logic. Works on either script's content — instance <script> and <script module> (see extractScriptContent/extractModuleScriptContent).

Check if a return type string matches svelte2tsx's snippet return type pattern.

svelte2tsx transforms exported snippets into arrow functions with ReturnType<import('svelte').Snippet> as the return type annotation. The resolved return type includes unique symbol (from Svelte's non-exported SnippetReturn unique symbol) intersected with the branded render message. We match on both parts to avoid false positives — the branded message alone could theoretically be crafted by user code, but the unique symbol intersection cannot since SnippetReturn is not exported from svelte.

Whether a checker type is a Snippet instantiation, structurally: a named generic instantiation (referenceSymbolName) named Snippet that carries a call signature — by construction the same shape the TypeJson builder classifies as a Snippet reference.

Callers pass the bare type — a union wrapping the Snippet reference (optional widening, | null) doesn't match, and neither does an intersection (Snippet<[]> & {...}); strip or walk members first.

Remap diagnostic positions emitted against svelte2tsx virtuals back to original .svelte positions, in place.

Extractors locate diagnostics via getNodeLocation, which reads whatever source file the node lives in — for a <script module> declaration that's the virtual. normalizeDiagnosticPaths later rewrites file to the .svelte path but has no position input, so without this pass the published combination is the original file with the virtual's line — actively misleading. Runs over the whole batch keyed by file, so a diagnostic emitted against *another* component's virtual (a rename re-export re-analyzes its canonical in the canonical's own source file) remaps through that virtual's map.

Must run before normalizeDiagnosticPaths, which strips the virtual suffix this pass matches on. An unmappable position (no source map, or a node svelte2tsx synthesized) drops line/column — absence over a virtual line.

Pre-transformed Svelte virtual file data.

Produced by transformSvelteSource and consumed by analyzeSvelteModule to provide checker-backed analysis of Svelte components.

Synthesize a Snippet<[...]> type string from structured parameters.

Used for kind: 'snippet' declarations where the raw svelte2tsx type is implementation noise. Renders the normalized form — an optional parameter as b?: number, matching the structured parameter fields rather than the checker's widened b?: number | undefined, and a rest parameter with its ... marker (Svelte compile-errors rest parameters in {#snippet}, but analysis never runs that check — svelte2tsx passes them through, so the invalid-but-parseable case renders faithfully rather than dropping the marker).

Result of transformSvelteSource — a virtual file (when transform succeeded) plus any ingest-time diagnostics produced during the transform.

virtual is undefined when svelte2tsx threw; in that case diagnostics contains a transform_failed entry. When the transform succeeded but source map construction failed, virtual is populated and diagnostics contains a source_map_failed entry. The session's owned-entry stores both — the virtual (or transformFailed: true flag) and the ingest diagnostics.

Pre-transform a Svelte source file via svelte2tsx.

Produces a SvelteVirtualFile containing the transformed TypeScript content and source map. The virtual file can be included in a TypeScript program (via createAnalysisProgram({ virtualFiles })) so that the checker can resolve imported types, <script module> exports, and re-exports.

Errors at ingest are returned via diagnostics rather than thrown:

• svelte2tsx throws → transform_failed, virtual: undefined
• source map construction fails → source_map_failed, virtual populated

Diagnostic file paths are the original .svelte source ID; downstream normalization rewrites them to project-root-relative form.