sveld 0.35.2 → 0.36.0

package/lib/parser/props.d.ts

@@ -1,71 +0,0 @@
-import type { ArrowFunctionExpression, FunctionDeclaration, FunctionExpression } from "estree";
-import type ComponentParser from "../ComponentParser";
-import type { ComponentProp, ComponentPropParam, ProcessedInitializer } from "../ComponentParser";
-import type { ParserContext } from "./context";
-export declare function addProp(parser: ComponentParser, ctx: ParserContext, prop_name: string, data: ComponentProp): void;
-export declare function processInitializer(parser: ComponentParser, ctx: ParserContext, init: unknown, depth?: number): ProcessedInitializer;
-/**
- * Look up a local variable's initializer AST node by name.
- * Returns the init node if found, or undefined.
- */
-export declare function resolveLocalVarInitializer(ctx: ParserContext, name: string): unknown | undefined;
-/**
- * Look up the initializer for a local `const` by name.
- *
- * {@link resolveLocalVarInitializer} also walks `let`/`var`. This method does not.
- * Props and mutable bindings can change at runtime, so they cannot be context keys.
- *
- * @param name - The variable name to look up
- * @returns The initializer node for a matching `const` binding, or undefined
- */
-export declare function resolveConstInitializer(ctx: ParserContext, name: string): unknown | undefined;
-/**
- * Build a function type from `@param`/`@returns` when `@type` is missing.
- * If JSDoc has no params or return either, try the function `node`, then
- * `(...args: any[]) => any`.
- */
-export declare function buildFunctionTypeFromParts(jsdoc?: {
-    params?: ComponentPropParam[];
-    returnType?: string;
-}, node?: FunctionDeclaration | FunctionExpression | ArrowFunctionExpression): string;
-/**
- * Guess arity and return type for a function default with no JSDoc `@type`.
- * Explicit `@type`/`@param`/`@returns` on the prop beat this every time.
- * A default's body is a weak signal for the prop contract. We only read
- * named params and literal returns. Everything else becomes `any`.
- */
-export declare function inferFunctionTypeFromNode(node: FunctionDeclaration | FunctionExpression | ArrowFunctionExpression): string;
-/**
- * Turn params into `name: any`, or use `...args: any[]` when arity is unclear:
- * no params, destructuring, rest, or defaults.
- */
-export declare function inferParamsFromNode(node: FunctionDeclaration | FunctionExpression | ArrowFunctionExpression): string;
-/**
- * Infer return type from literal returns only. Every `return` must agree on
- * the same primitive. Bare `return;`, no returns, identifiers, calls,
- * objects, ternaries, async, or generators all become `any`.
- */
-export declare function inferReturnTypeFromNode(node: FunctionDeclaration | FunctionExpression | ArrowFunctionExpression): string;
-/**
- * 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[];
-/**
- * Map one return expression to `string`, `number`, or `boolean`, or `null`
- * if it isn't a literal, template literal, or `String`/`Number`/`Boolean` call.
- */
-export declare function inferReturnPrimitive(expr: unknown): "string" | "number" | "boolean" | null;
-/**
- * Unwraps `$bindable(...)` calls so defaults are documented as their underlying values.
- */
-export declare function unwrapBindableInitializer(init: unknown): {
-    init?: unknown;
-    bindable: boolean;
-};

package/lib/parser/rest-props.d.ts

@@ -1,4 +0,0 @@
-import type { RestProps } from "../ComponentParser";
-import type { ParserContext } from "./context";
-export declare function createRestPropsFromParent(parent: unknown): RestProps;
-export declare function maybeSetRestProps(ctx: ParserContext, parent: unknown): void;

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

@@ -1,13 +0,0 @@
-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.
- *
- * Mirrors svelte analyze runes detection. Omitted: top-level `await` forces runes (no fixture).
- */
-export declare function detectSyntaxMode(ctx: ParserContext): SyntaxMode;

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

@@ -1,18 +0,0 @@
-import type { VariableDeclaration } from "estree";
-import type ComponentParser from "../ComponentParser";
-import type { ModernRunesTypeNode, RunesPropTypeMetadata } from "../ComponentParser";
-import type { ParserContext } from "./context";
-/** Flatten a runes `$props()` type node into prop name -> metadata, following local aliases and intersections. */
-export declare function buildRunesPropTypeMetadataMap(parser: ComponentParser, ctx: ParserContext, typeNode: ModernRunesTypeNode | undefined, localTypeDeclarations: Map<string, ModernRunesTypeNode>, visitedTypeNames?: Set<string>): Map<string, RunesPropTypeMetadata>;
-/**
- * Re-parse `ctx.source` in modern AST mode before the legacy walk: type imports,
- * local types, explicit `export let` annotations, and `$props()` metadata.
- */
-export declare function buildRunesPropTypeMetadata(parser: ComponentParser, ctx: ParserContext): void;
-/** Top-level `$props()` declarations in runes components. */
-export declare function parseRunesPropsDeclaration(parser: ComponentParser, ctx: ParserContext, node: VariableDeclaration): void;
-/**
- * Runes-only: fold phantom `@event` entries into matching `on<Event>` callback props
- * when nothing in the component actually dispatches that event.
- */
-export declare function normalizeRunesCallbackProps(ctx: ParserContext, actuallyDispatchedEvents: Set<string>): void;

package/lib/parser/scopes.d.ts

@@ -1,56 +0,0 @@
-import type { ArrowFunctionExpression, Expression, FunctionDeclaration, FunctionExpression, Pattern, VariableDeclaration, VariableDeclarator } from "estree";
-import type ComponentParser from "../ComponentParser";
-import type { LexicalScope, ScopeBinding, ScopeBindingKind } from "../ComponentParser";
-import type { ParserContext } from "./context";
-export declare function declareScopeBinding(scope: LexicalScope, name: string, binding: ScopeBinding): void;
-export declare function resolveIdentifierToReactiveProp(ctx: ParserContext, name: string): string | undefined;
-/** Collects all identifier names bound by a destructuring/assignment pattern (or plain expression). */
-export declare function collectPatternIdentifiers(target: Pattern | Expression | null | undefined, names?: Set<string>): Set<string>;
-/** Marks any reactive props referenced by a mutation target (assignment LHS / update argument) as reactive. */
-export declare function markReactivePropsFromMutationTarget(ctx: ParserContext, target: Pattern | Expression | null | undefined): void;
-/** True for AST/Svelte node types that introduce a new lexical scope. */
-export declare function isScopeOwner(node: unknown): boolean;
-/** True for node types that introduce a new `var`-hoisting (function) scope. */
-export declare function isFunctionScopeOwner(node: unknown): boolean;
-/** Returns the scope map for `node`, creating and caching an empty one on first access. */
-export declare function getOrCreateScope(ctx: ParserContext, node: object): LexicalScope;
-/** Scope bindings from `const { a, b: c } = $props()`. Destructured props are `prop`; rest is `local`. */
-export declare function extractRunesScopeBindings(parser: ComponentParser, _node: VariableDeclaration, declarator: VariableDeclarator): {
-    kind: ScopeBindingKind;
-    name: string;
-    publicPropName?: string;
-}[];
-/** Declares bindings for every declarator in a `var`/`let`/`const` declaration into the appropriate scope. */
-export declare function declareVariableDeclaration(parser: ComponentParser, declaration: unknown, lexicalScope: LexicalScope, varScope: LexicalScope, options?: {
-    allowRunesProps?: boolean;
-    forceProp?: boolean;
-}): void;
-/** Declares a function-like node's own name (if any) and its parameter bindings into `scope`. */
-export declare function declareFunctionLikeScopeBindings(node: FunctionExpression | ArrowFunctionExpression | FunctionDeclaration, scope: LexicalScope): void;
-/** Declares top-level `var`/`function`/`class` bindings directly within a block's statement list. */
-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;
-/**
- * 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

@@ -1,24 +0,0 @@
-import type { Expression, ObjectExpression } from "estree";
-import type ComponentParser from "../ComponentParser";
-import type { DeprecatedValue, JsDocPassthroughTag, SlotProps, SlotPropValue, SourceRange } from "../ComponentParser";
-import type { ParserContext } from "./context";
-export declare function inferSlotPropValueFromExpression(ctx: ParserContext, parser: ComponentParser, expression: unknown): SlotPropValue;
-export declare function buildSlotPropsFromObjectExpression(ctx: ParserContext, parser: ComponentParser, expression: ObjectExpression): SlotProps;
-export declare function resolveRenderTagPropReference(ctx: ParserContext, callee: unknown): {
-    publicName: string;
-    trackingName: string;
-} | null;
-export declare function extractRenderTagInfo(ctx: ParserContext, expression: unknown): {
-    publicName: string;
-    trackingName: string;
-    arguments: Array<Expression | unknown>;
-} | null;
-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 | SlotProps;
-    slot_fallback?: string;
-    slot_description?: string;
-    slot_deprecated?: DeprecatedValue;
-    slot_tags?: JsDocPassthroughTag[];
-    source?: SourceRange;
-}): void;

package/lib/parser/source-position.d.ts

@@ -1,26 +0,0 @@
-import type { SourcePosition, SourceRange } from "../ComponentParser";
-import type { ParserContext } from "./context";
-/**
- * Returns (and lazily computes/caches on `ctx`) the 0-based source offset for
- * the start of each line in `ctx.source`.
- */
-export declare function getSourceLineStartOffsets(ctx: ParserContext): number[];
-export declare function sourcePositionFromOffset(ctx: ParserContext, offset: number): SourcePosition | undefined;
-export declare function sourceRangeFromOffsets(ctx: ParserContext, start: number | undefined, end: number | undefined): SourceRange | undefined;
-export declare function sourceRangeFromNode(ctx: ParserContext, node: unknown): SourceRange | undefined;
-/**
- * Computes the {@link SourceRange} for a JSDoc tag within a parsed comment
- * block, given the block's own source lines and starting offset.
- */
-export declare function sourceRangeFromCommentTag(ctx: ParserContext, blockSource: Array<{
-    number: number;
-    source: string;
-}>, tagSource: Array<{
-    number: number;
-    source: string;
-    tokens: {
-        tag?: string;
-    };
-}> | undefined, blockStartOffset: number | undefined): SourceRange | undefined;
-export declare function sourceAtPos(ctx: ParserContext, start: number, end: number): string | undefined;
-export declare function sourceForExpression(ctx: ParserContext, node: unknown): string | undefined;

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

@@ -1,17 +0,0 @@
-import type { ModernRunesTypeNode, ParsedComponentTypeScriptMetadata } from "../ComponentParser";
-import type { ParserContext } from "./context";
-export declare function getRunesPropsDeclarationMetadata(ctx: ParserContext, declaratorStart: number | undefined): import("../ComponentParser").RunesPropsDeclarationMetadata | undefined;
-export declare function getRunesPropTypeMetadata(ctx: ParserContext, declaratorStart: number | undefined, propName: string): import("../ComponentParser").RunesPropTypeMetadata | undefined;
-export declare function getTypeReferenceName(typeName: unknown): string | undefined;
-export declare function getTypeDependencyName(typeName: unknown): string | undefined;
-export declare function getTypeAnnotationText(ctx: ParserContext, typeAnnotation: {
-    start?: number;
-    end?: number;
-} | undefined): string | undefined;
-export declare function getTypeNodeText(ctx: ParserContext, typeNode: {
-    start?: number;
-    end?: number;
-} | undefined): string | undefined;
-export declare function collectReferencedTypeDependencies(ctx: ParserContext, typeNode: ModernRunesTypeNode | undefined, referencedImportedTypes: Set<string>, referencedLocalTypes: Set<string>, visitedLocalTypes?: Set<string>): void;
-export declare function buildTypeImportStatements(ctx: ParserContext, referencedImportedTypes: Set<string>): string[];
-export declare function buildTypeScriptMetadata(ctx: ParserContext): ParsedComponentTypeScriptMetadata | undefined;

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

@@ -1 +0,0 @@
-export declare function stripTypeCastWrappers(root: unknown): void;

package/lib/parser/utils.d.ts

@@ -1 +0,0 @@
-export declare function assignValueOrUndefined(value?: "" | string): string | undefined;

package/lib/parser/variable-jsdoc.d.ts

@@ -1,12 +0,0 @@
-import type ComponentParser from "../ComponentParser";
-import type { ParserContext } from "./context";
-/**
- * Maps every top-level variable/function name declared in a component's module and instance
- * scripts to the `@type`/description from its attached JSDoc block. Used by
- * {@link ComponentParser.findVariableTypeAndDescription} to resolve plain identifiers (e.g. a
- * value passed to `setContext`) that aren't otherwise typed by a prop or a TS annotation.
- */
-export declare function buildVariableJsDocTable(ctx: ParserContext, parser: ComponentParser): Map<string, {
-    type: string;
-    description?: string;
-}>;

package/lib/parser-stack.d.ts

@@ -1,20 +0,0 @@
-/**
- * Lazily loads the parser stack (`ComponentParser` and the pruned svelte
- * parser in `./svelte-parse`, which together pull in acorn,
- * `@sveltejs/acorn-typescript`, comment-parser, and estree-walker) behind a
- * dynamic import.
- *
- * A fully cached run never needs to parse a single component, so it never
- * has to pay for evaluating any of that. Callers that are about to parse
- * (`bundle.ts`, `parse-entry-exports.ts`, `watch.ts`) await
- * `loadParserStack()` once up front, then read the resolved stack back
- * synchronously via `getParserStack()` for the rest of the (otherwise
- * synchronous) parse path. The load happens at most once per process.
- */
-export interface ParserStack {
-    ComponentParser: typeof import("./ComponentParser").default;
-    parseSvelte: typeof import("./svelte-parse").parse;
-}
-export declare function loadParserStack(): Promise<ParserStack>;
-/** Reads back the stack resolved by a prior, already-awaited `loadParserStack()` call. */
-export declare function getParserStack(): ParserStack;

package/lib/path.d.ts

@@ -1,2 +0,0 @@
-import type { NormalizedPath } from "./brands";
-export declare function normalizeSeparators(filePath: string): NormalizedPath;

package/lib/plugin.d.ts

@@ -1,85 +0,0 @@
-import { type GenerateBundleOptions, type GenerateBundleResult } from "./bundle";
-import "./writer/built-in-writers";
-import type { WriteCustomElementsOptions } from "./writer/writer-custom-elements";
-import type { WriteJsonOptions } from "./writer/writer-json";
-import type { WriteMarkdownOptions } from "./writer/writer-markdown";
-import type { WriteTsDefinitionsOptions } from "./writer/writer-ts-definitions";
-export type { CollectedComponents, ComponentDocApi, ComponentDocs, ComponentParseError, GenerateBundleOptions, GenerateBundleResult, ResolveComponentFilePath, } from "./bundle";
-export { collectComponents, collectSvelteFilePaths, generateBundle, processComponent, readFileMap, reportParseErrors, toGenerateBundleOptions, } from "./bundle";
-export interface PluginSveldOptions extends Pick<GenerateBundleOptions, "resolveTypes" | "cache" | "checkExamples"> {
-    /**
-     * Specify the entry point to uncompiled Svelte source.
-     * If not provided, sveld will use the "svelte" field from package.json.
-     */
-    entry?: string;
-    glob?: boolean;
-    /** Record consts, functions, and types from the entry barrel. Off by default. */
-    documentExports?: boolean;
-    types?: boolean;
-    typesOptions?: Partial<Omit<WriteTsDefinitionsOptions, "inputDir">>;
-    json?: boolean;
-    jsonOptions?: Partial<Omit<WriteJsonOptions, "inputDir">>;
-    markdown?: boolean;
-    markdownOptions?: Partial<WriteMarkdownOptions>;
-    /** Generate a Custom Elements Manifest (`custom-elements.json`, schemaVersion "1.0.0"). */
-    customElements?: boolean;
-    customElementsOptions?: Partial<Omit<WriteCustomElementsOptions, "inputDir">>;
-    /**
-     * Run additional, userland-registered writers (via `registerWriter` from
-     * "sveld") beyond the built-in `json`/`markdown`/`types` outputs. Keyed by
-     * the writer's registered `name`, valued by that writer's options.
-     */
-    additionalWriters?: Record<string, unknown>;
-    /**
-     * Abort the entire run when a single component fails to parse.
-     * When `false` (the default), parse failures are collected as diagnostics
-     * and the remaining components still emit their output.
-     */
-    failFast?: boolean;
-    /**
-     * Regenerate output incrementally when `.svelte` source changes during
-     * `vite dev` / `vite build --watch`. Only the changed component and the
-     * components that depend on it via `@extendProps` / `@extends` are re-parsed.
-     * @default false
-     */
-    watch?: boolean;
-}
-/** Subset of Vite/Rollup's HMR context that the watch hook relies on. */
-interface HotUpdateContext {
-    file: string;
-}
-interface SveldPlugin {
-    name: string;
-    apply?: "build" | "serve";
-    enforce?: "pre" | "post";
-    buildStart(): void | Promise<void>;
-    generateBundle(): Promise<void>;
-    writeBundle(): Promise<void>;
-    /** Vite dev-server HMR hook (serve mode). */
-    handleHotUpdate?(ctx: HotUpdateContext): void;
-    /** Rollup/Vite watch hook (build `--watch`). */
-    watchChange?(id: string): void;
-}
-export default function pluginSveld(opts?: PluginSveldOptions): SveldPlugin;
-/**
- * Writes output files based on plugin options.
- *
- * Generates TypeScript definitions, JSON metadata, and/or Markdown documentation
- * based on the options provided. Uses different component sets for different
- * output types to match expected behavior.
- *
- * @param result - Bundle result containing exports and component documentation
- * @param opts - Plugin options determining what outputs to generate
- * @param input - Input file path for determining input directory
- *
- * @example
- * ```ts
- * await writeOutput(result, {
- *   types: true,
- *   json: true,
- *   markdown: true
- * }, "./src/App.svelte");
- * // Generates: types/*.d.ts, COMPONENT_API.json, COMPONENT_INDEX.md
- * ```
- */
-export declare function writeOutput(result: GenerateBundleResult, opts: PluginSveldOptions, input: string): Promise<void>;

package/lib/resolve-alias.d.ts

@@ -1,30 +0,0 @@
-/** Clears cached tsconfig/jsconfig reads (tests and hot reload). */
-export declare function clearConfigCache(): void;
-/**
- * Resolve a tsconfig/jsconfig path alias to an absolute filesystem path.
- *
- * @example
- * ```ts
- * // With tsconfig.json: { "paths": { "$lib/*": ["./src/lib/*"] } }
- * resolvePathAliasAbsolute("$lib/utils", "./src")
- * // Returns: "/absolute/path/to/src/lib/utils"
- *
- * resolvePathAliasAbsolute("./relative", "./src")
- * // Returns: "./relative" (unchanged, not an alias)
- * ```
- */
-export declare function resolvePathAliasAbsolute(importPath: string, fromDir: string): string;
-/**
- * Resolve a path alias to a path relative to `fromDir` for generated exports.
- *
- * @example
- * ```ts
- * // With alias "$lib/utils" -> "./src/lib/utils"
- * resolvePathAlias("$lib/utils", "./src")
- * // Returns: "./lib/utils"
- *
- * resolvePathAlias("./Button.svelte", "./src")
- * // Returns: "./Button.svelte" (unchanged, not an alias)
- * ```
- */
-export declare function resolvePathAlias(importPath: string, fromDir: string): string;

package/lib/resolve-types.d.ts

@@ -1,52 +0,0 @@
-import type { ParsedComponentTypeScriptMetadata, ResolvedComponentProp } from "./ComponentParser";
-import type { ExampleCheckSource } from "./example-check";
-export interface ResolveTarget {
-    moduleName: string;
-    filePath: string;
-    metadata: ParsedComponentTypeScriptMetadata;
-}
-export interface ExampleCheckTarget {
-    moduleName: string;
-    filePath: string;
-    sources: ExampleCheckSource[];
-}
-/** One `@example` block that failed to type-check. */
-export interface ExampleCheckDiagnostic {
-    id: string;
-    name: string;
-    message: string;
-}
-/**
- * Expands opaque imported `$props()` types using the project's TypeScript program.
- * Loaded only when `resolveTypes` is enabled.
- */
-export declare class TypeResolver {
-    private readonly api;
-    private readonly symbolFlags;
-    private readonly typeFlags;
-    private readonly tsconfigPath;
-    private readonly overlay;
-    private constructor();
-    /**
-     * Loads `typescript` and the nearest `tsconfig.json`.
-     * Returns `null` when either is missing.
-     */
-    static create(cwd?: string): Promise<TypeResolver | null>;
-    /** Resolves every target in one program snapshot. */
-    expandAll(targets: ResolveTarget[]): Promise<Map<string, ResolvedComponentProp[]>>;
-    /**
-     * Type-checks every `@example` block in one program snapshot.
-     *
-     * Each example gets its own virtual file: a `declare`-style binding for the
-     * documented symbol (typed as `any` end-to-end, so types sveld can't see
-     * never cause a false positive), then the example body. Catches renamed
-     * or removed symbols and wrong arity. Not full type checking; it does not
-     * depend on the rest of the component's types.
-     */
-    checkExamples(targets: ExampleCheckTarget[]): Promise<Map<string, ExampleCheckDiagnostic[]>>;
-    /** Closes the TypeScript server process. */
-    dispose(): Promise<void>;
-    private createFileSystem;
-    private virtualFileName;
-    private exampleFileName;
-}

package/lib/sveld.d.ts

@@ -1,29 +0,0 @@
-import { type CheckResult } from "./check";
-import { type SveldDiagnostic } from "./diagnostics";
-import { type SveldRuntimeOptions } from "./load-config";
-type SveldOptions = SveldRuntimeOptions;
-/**
- * Result of a programmatic `sveld` run.
- */
-interface SveldResult {
-    /** Diagnostics from this run. */
-    diagnostics: SveldDiagnostic[];
-    /** Populated when `check` is enabled: the API diff against the committed snapshot. */
-    check?: CheckResult;
-}
-/**
- * Programmatic entry point for sveld.
- *
- * @example
- * ```ts
- * await sveld({
- *   entry: "./src",
- *   types: true,
- *   json: true,
- *   markdown: true,
- *   glob: true
- * });
- * ```
- */
-export declare function sveld(opts?: SveldOptions): Promise<SveldResult>;
-export {};

package/lib/svelte-parse.d.ts

@@ -1,4 +0,0 @@
-export declare function parse(source: string, { modern, loose }?: {
-    modern?: boolean;
-    loose?: boolean;
-}): unknown;

package/lib/svelte-version.d.ts

@@ -1 +0,0 @@
-export declare const VERSION: string;

package/lib/validate.d.ts

@@ -1,13 +0,0 @@
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
-export interface ParsedPackageJson {
-    svelte?: string;
-}
-export declare function parsePackageJson(value: unknown): ParsedPackageJson;
-export interface ParsedTsConfig {
-    compilerOptions?: {
-        baseUrl?: string;
-        paths?: Record<string, string[]>;
-    };
-    extends?: string;
-}
-export declare function parseTsConfig(value: unknown): ParsedTsConfig;

package/lib/watch.d.ts

@@ -1,34 +0,0 @@
-import { type GenerateBundleResult } from "./bundle";
-/** Result of an incremental update. */
-export interface SveldBundleUpdate {
-    /** The full, updated bundle result (all components, with the affected ones re-parsed). */
-    result: GenerateBundleResult;
-    /**
-     * Absolute paths of the components that were re-parsed: the changed files
-     * plus their transitive `@extendProps` / `@extends` dependents. Other
-     * components are reused from the previous parse.
-     */
-    reparsed: string[];
-}
-/**
- * A long-lived bundle that supports scoped, incremental re-parsing.
- *
- * `createSveldBundle` performs the initial full parse. `update` then re-parses
- * only the components affected by a set of changed files, leaving every other
- * component's previously-parsed output untouched. This is the core of the
- * plugin's watch mode.
- */
-export interface SveldBundle {
-    readonly result: GenerateBundleResult;
-    /** Re-parse the changed files plus their dependents and return the updated bundle. */
-    update(changedFilePaths: string[]): Promise<SveldBundleUpdate>;
-}
-/**
- * Creates a watch-mode bundle for the given entry point, performing the initial
- * full parse up front.
- *
- * @param input - Entry point file or directory containing Svelte components
- * @param glob - Whether to glob for all `.svelte` files in the directory
- * @param documentExports - Record consts, functions, and types from the entry barrel
- */
-export declare function createSveldBundle(input: string, glob: boolean, documentExports?: boolean): Promise<SveldBundle>;

package/lib/writer/MarkdownWriterBase.d.ts

@@ -1,26 +0,0 @@
-export type AppendType = "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "quote" | "p" | "divider" | "raw";
-export interface TocLine {
-    /** Leading space count; 0 for the top-level (`h2`) entries the TOC currently lists. */
-    indent: number;
-    raw: string;
-}
-export interface MarkdownWriterBase {
-    sourceParts: string[];
-    hasToC: boolean;
-    toc: TocLine[];
-    appendLineBreaks(): this;
-    append(type: AppendType, raw?: string): this;
-    tableOfContents(): this;
-    end(): string;
-    get source(): string;
-}
-export declare class MarkdownWriterBaseImpl implements MarkdownWriterBase {
-    sourceParts: string[];
-    hasToC: boolean;
-    toc: TocLine[];
-    get source(): string;
-    appendLineBreaks(): this;
-    append(type: AppendType, raw?: string): this;
-    tableOfContents(): this;
-    end(): string;
-}

package/lib/writer/Writer.d.ts

@@ -1,31 +0,0 @@
-export default class Writer {
-    /**
-     * Skips the write when `filePath` already contains `raw`, so repeated runs
-     * over unchanged sources don't touch the file (or its mtime).
-     *
-     * @returns `true` if the file was written, `false` if it was already up to date.
-     *
-     * @example
-     * ```ts
-     * const writer = new Writer();
-     * await writer.write("./dist/index.d.ts", "export type Props = {};");
-     * ```
-     */
-    write(filePath: string, raw: string): Promise<boolean>;
-}
-/**
- * @example
- * ```ts
- * const writer = createJsonWriter();
- * await writer.write("data.json", JSON.stringify({ key: "value" }));
- * ```
- */
-export declare function createJsonWriter(): Writer;
-/**
- * @example
- * ```ts
- * const writer = createTypeScriptWriter();
- * await writer.write("index.d.ts", "export type Props = {};");
- * ```
- */
-export declare function createTypeScriptWriter(): Writer;

package/lib/writer/WriterMarkdown.d.ts

@@ -1,31 +0,0 @@
-import { type AppendType } from "./MarkdownWriterBase";
-import Writer from "./Writer";
-type OnAppend = (type: AppendType, document: WriterMarkdown) => void;
-interface MarkdownOptions {
-    onAppend?: OnAppend;
-}
-export type { AppendType };
-/**
- * @example
- * ```ts
- * const writer = new WriterMarkdown({
- *   onAppend: (type, doc) => {
- *     console.log(`Appended ${type} to markdown`);
- *   }
- * });
- * writer.append("h1", "Title");
- * await writer.write("./docs.md", writer.end());
- * ```
- */
-export default class WriterMarkdown extends Writer {
-    onAppend?: OnAppend;
-    private markdownBase;
-    constructor(options: MarkdownOptions);
-    get source(): string;
-    get hasToC(): boolean;
-    get toc(): import("./MarkdownWriterBase").TocLine[];
-    appendLineBreaks(): this;
-    append(type: AppendType, raw?: string): this;
-    tableOfContents(): this;
-    end(): string;
-}

package/lib/writer/built-in-writers.d.ts

@@ -1 +0,0 @@
-export {};