sveld 0.35.0 → 0.35.1

package/lib/parse-exports.d.ts

@@ -17,5 +17,9 @@ export type ParsedExports = Record<string, {
  * //   App: { source: "./App.svelte", default: true }
  * // }
  * ```
+ *
+ * @param resolving - Absolute paths currently being resolved on this call
+ *   stack, used to break `export *` cycles between files that re-export
+ *   each other. Callers should not pass this; it is threaded internally.
  */
-export declare function parseExports(source: string, dir: string): ParsedExports;
+export declare function parseExports(source: string, dir: string, resolving?: Set<string>): ParsedExports;

package/lib/parser/context.d.ts

@@ -1,6 +1,5 @@
 import type { FunctionDeclaration, VariableDeclaration } from "estree";
-import type { compile } from "svelte/compiler";
-import type { ComponentContext, ComponentElement, ComponentEvent, ComponentGenerics, ComponentInlineElement, ComponentProp, ComponentPropBindings, ComponentSlot, Extends, LegacyAstRoot, LexicalScope, LocalTypeDeclaration, RestProps, RunesPropsDeclarationMetadata, ScriptLanguage, SourceRange, SyntaxMode, TypeDef, TypeImportBinding } from "../ComponentParser";
+import type { ComponentContext, ComponentElement, ComponentEvent, ComponentGenerics, ComponentInlineElement, ComponentProp, ComponentPropBindings, Extends, InternalComponentSlot, LegacyAstRoot, LexicalScope, LocalTypeDeclaration, RestProps, RunesPropsDeclarationMetadata, ScriptLanguage, SourceRange, SyntaxMode, TypeDef, TypeImportBinding } from "../ComponentParser";
 import type { SveldDiagnostic } from "../diagnostics";
 /** Per-parse mutable state for {@link ComponentParser}. Reset via {@link createParserContext} on each parse. */
 export interface ParserContext {
@@ -10,10 +9,13 @@ export interface ParserContext {
     scriptLanguage?: ScriptLanguage;
     /** Raw source code of the Svelte component being parsed */
     source?: string;
-    /** Compiled Svelte code containing extracted variables and AST */
-    compiled?: ReturnType<typeof compile>;
     /** Parsed abstract syntax tree from the Svelte compiler */
     parsed?: LegacyAstRoot;
+    /**
+     * Explicit `<svelte:options runes={...} />` value, resolved during the modern-mode parse for
+     * runes prop type metadata. When present, overrides rune-reference detection.
+     */
+    runesOptionOverride?: boolean;
     /** Cached `ctx.source` split on newlines */
     sourceLinesCache?: string[];
     /** Cached 0-based source offsets for the start of each line */
@@ -76,7 +78,7 @@ export interface ParserContext {
     /** Active lexical scopes while walking the component AST */
     readonly activeScopes: LexicalScope[];
     /** Map of component slots keyed by slot name (null for default slot) */
-    readonly slots: Map<string | null, ComponentSlot>;
+    readonly slots: Map<string | null, InternalComponentSlot>;
     /** Tracks prop locals that are used as snippet/render props */
     readonly snippetPropLocals: Set<string>;
     /** @template tags in a @slot/@snippet block (no @extends), held until finalization. */
@@ -105,6 +107,8 @@ export interface ParserContext {
         type: string;
         description?: string;
     }>;
+    /** Whether {@link variableInfoCache} has been populated by a whole-source scan yet */
+    variableInfoCacheBuilt: boolean;
 }
 /** Fresh {@link ParserContext}. Keep in sync with new fields on {@link ParserContext}. */
 export declare function createParserContext(): ParserContext;

package/lib/parser/props.d.ts

@@ -51,6 +51,12 @@ export declare function inferReturnTypeFromNode(node: FunctionDeclaration | Func
 /**
  * Walk a block body and collect each `return`'s argument, skipping nested
  * functions. Bare `return;` becomes `null`.
+ *
+ * Not fused with the componentRoot walk: this runs from `processInitializer`, called
+ * synchronously while the outer walk is still on the ancestor `ExportNamedDeclaration`/
+ * `VariableDeclaration` node, so it needs the inferred type before the outer walk would
+ * otherwise reach these descendant statements. Deferring it to ride along with the outer
+ * traversal would mean computing prop types in a second pass instead of inline.
  */
 export declare function collectReturnArguments(body: unknown): unknown[];
 /**

package/lib/parser/runes-detection.d.ts

@@ -0,0 +1,16 @@
+import type { SyntaxMode } from "../ComponentParser";
+import type { ParserContext } from "./context";
+/**
+ * Determines a component's syntax mode without running the svelte compiler's analyze phase.
+ *
+ * Mirrors `analyze_component`'s own logic (`node_modules/svelte/src/compiler/phases/2-analyze/index.js`):
+ * an explicit `<svelte:options runes={...} />` always wins; otherwise the component is in runes
+ * mode if any rune name is referenced - and not shadowed by a local declaration of the same name -
+ * anywhere in the module script, instance script, or template.
+ *
+ * Known simplification: svelte also force-enables runes mode on top-level `await` (blocking awaits
+ * outside of any function). No sveld fixture exercises that path, so it's intentionally not
+ * replicated here; a component relying solely on top-level `await` to opt into runes mode (with no
+ * other rune usage and no explicit `svelte:options`) would be misdetected as legacy.
+ */
+export declare function detectSyntaxMode(ctx: ParserContext): SyntaxMode;

package/lib/parser/scopes.d.ts

@@ -1,5 +1,4 @@
 import type { ArrowFunctionExpression, Expression, FunctionDeclaration, FunctionExpression, Pattern, VariableDeclaration, VariableDeclarator } from "estree";
-import type { Node } from "estree-walker";
 import type ComponentParser from "../ComponentParser";
 import type { LexicalScope, ScopeBinding, ScopeBindingKind } from "../ComponentParser";
 import type { ParserContext } from "./context";
@@ -34,7 +33,26 @@ export declare function declareFunctionLikeScopeBindings(node: FunctionExpressio
 export declare function collectDirectBlockDeclarations(parser: ComponentParser, body: unknown, lexicalScope: LexicalScope, varScope: LexicalScope): void;
 /** Declares all component-instance-level (`<script>`) bindings into `ctx.componentScope`. */
 export declare function collectComponentScopeDeclarations(parser: ComponentParser, ctx: ParserContext, instance: unknown): void;
-/** Walks the component AST, declaring bindings for every nested lexical/function scope it encounters. */
-export declare function collectNestedScopeDeclarations(parser: ComponentParser, ctx: ParserContext, componentRoot: Node): void;
-/** Rebuilds `ctx.componentScope` / `ctx.scopeDeclarations` / `ctx.activeScopes` from scratch for `componentRoot`. */
-export declare function buildScopeDeclarations(parser: ComponentParser, ctx: ParserContext, componentRoot: Node): void;
+/**
+ * Resets `ctx.componentScope` / `ctx.scopeDeclarations` / `ctx.activeScopes` and declares the
+ * top-level `<script>` bindings. Does not walk the component tree; nested scope declarations are
+ * built incrementally by {@link enterNestedScopeDeclarationNode} inside the caller's own traversal
+ * of `componentRoot` (fused with prop/slot/event extraction there rather than walked separately).
+ */
+export declare function initComponentScope(parser: ComponentParser, ctx: ParserContext): void;
+/** Mutable stack tracking the enclosing `var`-hoisting scope while walking `componentRoot`. */
+export type ScopeWalkState = {
+    varScopeStack: LexicalScope[];
+};
+/** Creates the scope-walk state for a fresh traversal of `componentRoot`, seeded with `ctx.componentScope`. */
+export declare function createScopeWalkState(ctx: ParserContext): ScopeWalkState;
+/**
+ * Per-node `enter` step of the (formerly standalone) nested-scope-declaration walk. Declares
+ * bindings for `node` if it's a scope owner and pushes it as the active `var` scope for its
+ * descendants. Must be called during the same top-down traversal of `componentRoot` that
+ * {@link leaveNestedScopeDeclarationNode} tears down, and before any logic that reads
+ * `ctx.scopeDeclarations` for `node` itself (its own scope is only created here, on entry).
+ */
+export declare function enterNestedScopeDeclarationNode(parser: ComponentParser, ctx: ParserContext, state: ScopeWalkState, node: unknown): void;
+/** Per-node `leave` step counterpart to {@link enterNestedScopeDeclarationNode}. */
+export declare function leaveNestedScopeDeclarationNode(state: ScopeWalkState, node: unknown): void;

package/lib/parser/slots.d.ts

@@ -20,7 +20,7 @@ export declare function extractRenderTagInfo(ctx: ParserContext, expression: unk
 /** Merge or add a slot. Empty `slot_name` is the default slot. */
 export declare function addSlot(ctx: ParserContext, { slot_name, slot_props, slot_fallback, slot_description, slot_deprecated, slot_tags, source, }: {
     slot_name?: string;
-    slot_props?: string;
+    slot_props?: string | SlotProps;
     slot_fallback?: string;
     slot_description?: string;
     slot_deprecated?: DeprecatedValue;

package/lib/parser/type-resolution.d.ts

@@ -19,6 +19,11 @@ export declare function getTypeAnnotationText(ctx: ParserContext, typeAnnotation
     start?: number;
     end?: number;
 } | undefined): string | undefined;
+/** Returns the trimmed source text spanned by a bare type node (no leading `:`), if positions are available. */
+export declare function getTypeNodeText(ctx: ParserContext, typeNode: {
+    start?: number;
+    end?: number;
+} | undefined): string | undefined;
 /** Collect imported and local type names referenced by a type AST node. */
 export declare function collectReferencedTypeDependencies(ctx: ParserContext, typeNode: ModernRunesTypeNode | undefined, referencedImportedTypes: Set<string>, referencedLocalTypes: Set<string>, visitedLocalTypes?: Set<string>): void;
 /** Emit `import type` statements for referenced type names, grouped by module. */

package/lib/parser/typescript-casts.d.ts

@@ -0,0 +1,2 @@
+/** In-place: replaces every `expr as T` / `expr satisfies T` / `expr!` / `<T>expr` / `expr<T>` with `expr`. */
+export declare function stripTypeCastWrappers(root: unknown): void;

package/lib/resolve-types.d.ts

@@ -23,6 +23,7 @@ export interface ExampleCheckDiagnostic {
 export declare class TypeResolver {
     private readonly api;
     private readonly symbolFlags;
+    private readonly typeFlags;
     private readonly tsconfigPath;
     private readonly overlay;
     private constructor();
@@ -45,7 +46,6 @@ export declare class TypeResolver {
     checkExamples(targets: ExampleCheckTarget[]): Promise<Map<string, ExampleCheckDiagnostic[]>>;
     /** Closes the TypeScript server process. */
     dispose(): Promise<void>;
-    private resolveFile;
     private createFileSystem;
     private virtualFileName;
     private exampleFileName;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sveld",
-  "version": "0.35.0",
+  "version": "0.35.1",
   "license": "Apache-2.0",
   "description": "Generate TypeScript definitions and component documentation for your Svelte components.",
   "type": "module",
@@ -11,6 +11,11 @@
       "types": "./lib/index.d.ts",
       "import": "./lib/index.js",
       "default": "./lib/index.js"
+    },
+    "./browser": {
+      "types": "./lib/browser.d.ts",
+      "import": "./lib/browser.js",
+      "default": "./lib/browser.js"
     }
   },
   "bin": {