sveld 0.35.1 → 0.36.0

package/lib/ast-guards.d.ts

@@ -1,18 +0,0 @@
-import type { ArrowFunctionExpression, CallExpression, FunctionDeclaration, FunctionExpression, Identifier, Literal, MemberExpression, NewExpression, ObjectExpression, VariableDeclaration } from "estree";
-export declare function isObject(value: unknown): value is Record<string, unknown>;
-export declare function isVariableDeclaration(node: unknown): node is VariableDeclaration;
-export declare function isLiteral(node: unknown): node is Literal;
-export declare function isIdentifier(node: unknown): node is Identifier;
-export declare function isMemberExpression(node: unknown): node is MemberExpression;
-export declare function isObjectExpression(node: unknown): node is ObjectExpression;
-export declare function isCallExpression(node: unknown): node is CallExpression;
-export declare function isCallExpressionNamed(node: unknown, calleeName: string): node is CallExpression;
-/** Unwraps `expr as Type` / `expr satisfies Type`, returning the innermost expression. */
-export declare function unwrapTypeCastExpression(node: unknown): unknown;
-/** The type node from `expr as Type` / `expr satisfies Type`, if `node` is such a cast. */
-export declare function getTypeCastAnnotation(node: unknown): unknown;
-export declare function isNewExpression(node: unknown): node is NewExpression;
-export declare function isNewExpressionNamed(node: unknown, calleeName: string): node is NewExpression;
-export declare function isFunctionDeclaration(node: unknown): node is FunctionDeclaration;
-export declare function isFunctionExpression(node: unknown): node is FunctionExpression;
-export declare function isArrowFunctionExpression(node: unknown): node is ArrowFunctionExpression;

package/lib/brands.d.ts

@@ -1,11 +0,0 @@
-declare const brand: unique symbol;
-export type Brand<TBase extends string, TBrand extends string> = TBase & {
-    readonly [brand]: TBrand;
-};
-export type SvelteEntryPoint = Brand<string, "SvelteEntryPoint">;
-export declare function asSvelteEntryPoint(path: string): SvelteEntryPoint;
-export type NormalizedPath = Brand<string, "NormalizedPath">;
-export declare function asNormalizedPath(path: string): NormalizedPath;
-export type RelativeSourcePath = Brand<string, "RelativeSourcePath">;
-export declare function asRelativeSourcePath(path: string): RelativeSourcePath;
-export {};

package/lib/bundle.d.ts

@@ -1,176 +0,0 @@
-import { asRelativeSourcePath, type NormalizedPath } from "./brands";
-import { type ParsedComponent } from "./ComponentParser";
-import { type SveldDiagnostic } from "./diagnostics";
-import { ParseCache } from "./parse-cache";
-import { type EntryExports } from "./parse-entry-exports";
-import { type ParsedExports } from "./parse-exports";
-export interface ComponentDocApi extends ParsedComponent {
-    filePath: NormalizedPath;
-    moduleName: string;
-}
-export type ComponentDocs = Map<string, ComponentDocApi>;
-/**
- * A parse failure for a single component, captured so the rest of the run
- * can continue. Surfaced via {@link GenerateBundleResult.errors}.
- */
-export interface ComponentParseError {
-    filePath: string;
-    moduleName: string;
-    message: string;
-    stack?: string;
-}
-export interface GenerateBundleResult {
-    exports: ParsedExports;
-    /** Entry-barrel exports other than components. Empty when `documentExports` is off. */
-    entryExports: EntryExports;
-    components: ComponentDocs;
-    allComponentsForTypes: ComponentDocs;
-    /**
-     * Components that failed to parse. Empty unless `failFast` is disabled and
-     * one or more components threw during parsing.
-     */
-    errors: ComponentParseError[];
-    /** Unknown props, `any` contexts, and orphan `@event` tags across the bundle. */
-    diagnostics: SveldDiagnostic[];
-}
-export interface GenerateBundleOptions {
-    /**
-     * Throw on the first component that fails to parse instead of collecting
-     * the failure and continuing with the remaining components.
-     */
-    failFast?: boolean;
-    /**
-     * Load the TypeScript program to expand opaque imported whole-object `$props()`
-     * types into JSON/Markdown props. Off by default; requires `typescript`.
-     */
-    resolveTypes?: boolean;
-    /** Record consts, functions, and types from the entry barrel. Off by default. */
-    documentExports?: boolean;
-    /**
-     * Cache parsed component output to disk. Unchanged files skip re-parsing on
-     * later runs. On by default, writing to
-     * `node_modules/.cache/sveld/parse-cache.json`; a string sets a custom path.
-     * Pass `false` to disable.
-     */
-    cache?: boolean | string;
-    /**
-     * Run plain TS/JS `@example` blocks on props, module exports, slots, and
-     * events through the TypeScript program. Broken examples become
-     * `example-compile-error` diagnostics. Svelte/HTML markup is skipped.
-     * Off by default. Requires `typescript`.
-     */
-    checkExamples?: boolean;
-}
-export declare function toGenerateBundleOptions(opts?: Pick<GenerateBundleOptions, "failFast" | "resolveTypes" | "documentExports" | "cache" | "checkExamples">): GenerateBundleOptions;
-/** A function that resolves a (possibly relative) component path to an absolute path. */
-export type ResolveComponentFilePath = (filePath: string) => string;
-/** Options controlling how a single component parse failure is handled. */
-export interface ProcessComponentOptions {
-    /** Rethrow on parse failure instead of reporting it via `onParseError`. */
-    failFast?: boolean;
-    /** Invoked with a diagnostic when a component fails to parse (and `failFast` is off). */
-    onParseError?: (error: ComponentParseError) => void;
-    /** When set, reuse a component's previous parse if its content hash is unchanged. */
-    cache?: ParseCache;
-    /** Resolved file path -> sha256, computed once up front so it isn't re-hashed per pass. */
-    hashes?: Map<string, string>;
-    /**
-     * In-run memo of freshly parsed components, keyed by resolved file path and
-     * shared across the exported and all-components passes so a component that
-     * appears in both is only parsed once. Only fresh parses are stored here
-     * (never disk-cache hits), and an entry is cleared wherever the disk cache
-     * is invalidated so the `@extends` dependency-invalidation flow still forces
-     * a re-parse.
-     */
-    memo?: Map<string, ParsedComponent>;
-}
-export declare function stripTopLevelStyleBlock(source: string): string;
-/**
- * Discovered component sources for an entry point, before parsing.
- *
- * `exports` holds explicitly exported components (used for JSON/Markdown);
- * `allComponents` additionally includes glob-discovered components (used for
- * `.d.ts` generation). `resolveComponentFilePath` maps a component `source`
- * to its absolute path on disk.
- */
-export interface CollectedComponents {
-    exports: ParsedExports;
-    allComponents: ParsedExports;
-    rootDir: string;
-    resolveComponentFilePath: ResolveComponentFilePath;
-}
-/** A `.svelte` file discovered on disk, before it's merged into `exports`/`allComponents`. */
-export interface GlobbedComponentSource {
-    moduleName: string;
-    source: ReturnType<typeof asRelativeSourcePath>;
-}
-/** Globs every `.svelte` file under `rootDir`, resolving each to its module name and source path. */
-export declare function globComponentSources(rootDir: string): GlobbedComponentSource[];
-/**
- * Discovers component sources for an entry point without parsing them.
- *
- * Parses the entry's exports (when `input` is a file) and, when `glob` is set,
- * augments the set with every `.svelte` file under the entry directory.
- *
- * @param documentExports - When `true`, log and continue if the entry file fails
- *   the acorn component-export parse (TypeScript-only syntax is common).
- */
-export declare function collectComponents(input: string, glob: boolean, documentExports?: boolean): CollectedComponents;
-/**
- * Reads the given component file paths into a map of path -> contents.
- *
- * Failed reads are recorded as `null` (and logged) so callers can skip them
- * gracefully rather than aborting the whole bundle.
- */
-export declare function readFileMap(filePaths: Iterable<string>): Promise<Map<string, string | null>>;
-/**
- * Parses a single component entry into its documentation API.
- *
- * Reads the component contents from `fileMap`, removes top-level styles for
- * metadata parsing, and parses it to extract component metadata. Returns `null`
- * for non-Svelte entries or files that could not be read.
- *
- * A component that throws while parsing is captured via `options.onParseError`
- * (and `null` is returned) so callers can continue with the rest, unless
- * `options.failFast` is set, in which case the error is rethrown.
- *
- * @param entry - Export entry tuple `[exportName, exportInfo]`
- * @param entries - All sibling entries, used to resolve the module name
- * @param fileMap - Map of resolved file paths to their contents
- * @param resolveComponentFilePath - Resolves a component `source` to its absolute path
- * @param options - Parse-failure handling (`failFast` / `onParseError`)
- */
-export declare function processComponent([exportName, entry]: [string, ParsedExports[string]], entries: Array<[string, ParsedExports[string]]>, fileMap: Map<string, string | null>, resolveComponentFilePath: ResolveComponentFilePath, options?: ProcessComponentOptions): ComponentDocApi | null;
-/** Collects the resolved, absolute paths of all `.svelte` entries. */
-export declare function collectSvelteFilePaths(entriesList: Array<Array<[string, ParsedExports[string]]>>, resolveComponentFilePath: ResolveComponentFilePath): Set<string>;
-/** Reports collected component parse errors to stderr. No-op when empty. */
-export declare function reportParseErrors(errors: ComponentParseError[]): void;
-/**
- * Generates component documentation bundle from Svelte source files.
- *
- * Parses exports, discovers components (optionally via glob), and processes
- * all Svelte files to extract component metadata. Returns both exported
- * components (for JSON/Markdown) and all components (for TypeScript definitions).
- *
- * A single component that fails to parse is captured as a diagnostic (see
- * {@link GenerateBundleResult.errors}) so the remaining components still emit
- * output. Pass `{ failFast: true }` to restore abort-on-first-error behavior.
- *
- * @param input - Entry point file or directory containing Svelte components
- * @param glob - Whether to glob for all .svelte files in the directory
- * @param options - Bundle options (e.g. `failFast`, `resolveTypes`, `documentExports`)
- * @returns Bundle result containing exports, entryExports, components, allComponentsForTypes, and errors
- *
- * @example
- * ```ts
- * // Generate from single file:
- * const result = await generateBundle("./src/App.svelte", false);
- *
- * // Generate from directory with glob:
- * const result = await generateBundle("./src", true);
- *
- * // Abort on the first parse failure:
- * const result = await generateBundle("./src", true, { failFast: true });
- * ```
- */
-export declare function generateBundle(input: string, glob: boolean, options?: GenerateBundleOptions): Promise<GenerateBundleResult>;

package/lib/check.d.ts

@@ -1,43 +0,0 @@
-import type { ComponentDocs } from "./bundle";
-import type { SveldRuntimeOptions } from "./load-config";
-import type { EntryExports } from "./parse-entry-exports";
-import { type ComponentApiDocument } from "./writer/document-model";
-export type SemverBump = "major" | "minor" | "patch" | "none";
-/** One API diff between the committed snapshot and the current parse. */
-export interface ApiChange {
-    /** Component `moduleName` this change belongs to, or `"*"` for document-wide notices. */
-    component: string;
-    kind: "component" | "prop" | "moduleExport" | "event" | "slot" | "shape";
-    /** Prop, event, slot, or shape-field name, when applicable. */
-    name?: string;
-    bump: SemverBump;
-    message: string;
-}
-export interface CheckResult {
-    /** `false` when there was nothing on disk to diff against (e.g. first run). */
-    snapshotExists: boolean;
-    snapshotFile: string;
-    changes: ApiChange[];
-    /** Highest bump across all changes. */
-    bump: SemverBump;
-}
-/** Diffs two `COMPONENT_API.json` documents and assigns a semver bump to each change. */
-export declare function diffApiDocuments(previous: ComponentApiDocument, next: ComponentApiDocument): ApiChange[];
-export interface RunCheckOptions {
-    /** Entry-barrel exports when `documentExports` is on. */
-    entryExports?: EntryExports;
-}
-/**
- * Resolves the snapshot path for `check`: an explicit string wins, otherwise
- * it falls back to the `json` writer's `outFile`, or `COMPONENT_API.json`.
- */
-export declare function resolveCheckSnapshotFile(options: Pick<SveldRuntimeOptions, "check" | "jsonOptions">): string;
-/**
- * Diffs the current component set against a committed `COMPONENT_API.json`
- * snapshot and assigns a semver bump to each change. Returns
- * `snapshotExists: false` when no snapshot file exists yet, so the first
- * run does not fail CI.
- */
-export declare function runCheck(components: ComponentDocs, snapshotFile: string, options?: RunCheckOptions): Promise<CheckResult>;
-/** Groups changes by component for CLI output. */
-export declare function formatCheckReport(result: CheckResult): string;

package/lib/cli.d.ts

@@ -1,28 +0,0 @@
-import { type SveldRuntimeOptions } from "./load-config";
-/** CLI options: identical surface to the shared runtime options. */
-type CliOptions = SveldRuntimeOptions;
-/** Discriminated result of parsing the full argument list. */
-export type CliParseResult = {
-    kind: "options";
-    options: CliOptions;
-} | {
-    kind: "help";
-} | {
-    kind: "version";
-} | {
-    kind: "unknown";
-    arg: string;
-};
-export declare function parseCliOptions(argv: string[]): CliParseResult;
-/**
- * CLI entry point: parse flags, load any config file, generate docs, write
- * outputs.
- *
- * @example
- * ```ts
- * // Called from CLI: sveld --types --json --glob
- * // Parses: { types: true, json: true, glob: true }
- * ```
- */
-export declare function cli(process: NodeJS.Process): Promise<void>;
-export {};

package/lib/create-exports.d.ts

@@ -1,32 +0,0 @@
-import type { ParsedExports } from "./parse-exports";
-/**
- * Builds export statements from parsed export metadata.
- *
- * @example
- * ```ts
- * // Input:
- * { Button: { source: "./Button.svelte", default: true } }
- *
- * // Output:
- * // export { default as Button } from "./Button.svelte";
- * ```
- */
-export declare function createExports(parsed_exports: ParsedExports): string;
-/**
- * Strips the `.svelte` extension from a path.
- *
- * @example
- * ```ts
- * removeSvelteExt("./Button.svelte") // Returns: "./Button"
- * ```
- */
-export declare function removeSvelteExt(filePath: string): string;
-/**
- * Maps a `.svelte` path to its `.svelte.d.ts` definition path.
- *
- * @example
- * ```ts
- * convertSvelteExt("./Button.svelte") // Returns: "./Button.svelte.d.ts"
- * ```
- */
-export declare function convertSvelteExt(filePath: string): string;

package/lib/dependency-graph.d.ts

@@ -1,20 +0,0 @@
-import type { ComponentDocApi, ComponentDocs, ResolveComponentFilePath } from "./bundle";
-/**
- * Resolves a component's `@extendProps` / `@extends` target to an absolute path,
- * or `null` when it doesn't point at a local `.svelte` file (e.g. it references
- * an external package interface like `carbon-components-svelte`).
- */
-export declare function resolveExtendsDependency(api: ComponentDocApi, componentPath: string): string | null;
-/**
- * Builds a reverse-dependency map: `dependencyPath -> set of dependent paths`.
- *
- * A component is a dependent of `X` when it extends `X` via `@extendProps` /
- * `@extends`. When `X` changes, every dependent must be re-parsed.
- */
-export declare function buildReverseDeps(components: ComponentDocs, resolveComponentFilePath: ResolveComponentFilePath): Map<string, Set<string>>;
-/**
- * Expands the set of changed paths to include every transitive dependent via
- * the reverse-dependency map (e.g. editing `Button.svelte` also marks the
- * `SecondaryButton.svelte` that `@extendProps`-es it).
- */
-export declare function expandAffected(changed: Iterable<string>, reverseDeps: Map<string, Set<string>>): Set<string>;

package/lib/diagnostics.d.ts

@@ -1,34 +0,0 @@
-import type { SourceRange } from "./ComponentParser";
-/**
- * Why sveld could not pin a type during parsing.
- *
- * - `prop-unknown-type`: prop `typeSource` is `"unknown"`.
- * - `context-any-type`: `setContext` value inferred as `any`.
- * - `event-no-source`: `@event` with no dispatch, forward, or callback prop.
- * - `example-compile-error`: an `@example` block failed to type-check (opt-in, `checkExamples`).
- * - `syntax-skipped`: `$props()`/`{@render}` syntax the parser can't model; omitted from output.
- */
-export type SveldDiagnosticKind = "prop-unknown-type" | "context-any-type" | "event-no-source" | "example-compile-error" | "syntax-skipped";
-/**
- * One place sveld had to guess a type instead of inferring it.
- */
-export interface SveldDiagnostic {
-    /** File this came from, e.g. `"./Button.svelte"`. */
-    component: string;
-    kind: SveldDiagnosticKind;
-    /** Prop, context field, or event name. */
-    name: string;
-    /** What went wrong and what type sveld used. */
-    message: string;
-    /** Where in the component source this diagnostic points, when the parser holds a stable position. */
-    source?: SourceRange;
-}
-/**
- * Drop duplicates (same component, kind, and name). Each file is parsed twice
- * when building exports and `.d.ts`, so without this the CLI summary doubles.
- */
-export declare function dedupeDiagnostics(diagnostics: SveldDiagnostic[]): SveldDiagnostic[];
-/**
- * Group diagnostics by kind and component for CLI output.
- */
-export declare function formatDiagnosticsSummary(diagnostics: SveldDiagnostic[]): string;

package/lib/element-tag-map.d.ts

@@ -1,146 +0,0 @@
-/**
- * Tag-to-DOM-type map from TypeScript `lib.dom.d.ts`. Unknown tags fall back to `HTMLElement`.
- *
- * @example
- * ```ts
- * tag_map["button"] // "HTMLButtonElement"
- * tag_map["div"]    // "HTMLDivElement"
- * tag_map["input"]  // "HTMLInputElement"
- * ```
- */
-declare const tag_map: {
-    a: string;
-    abbr: string;
-    address: string;
-    applet: string;
-    area: string;
-    article: string;
-    aside: string;
-    audio: string;
-    b: string;
-    base: string;
-    basefont: string;
-    bdi: string;
-    bdo: string;
-    blockquote: string;
-    body: string;
-    br: string;
-    button: string;
-    canvas: string;
-    caption: string;
-    cite: string;
-    code: string;
-    col: string;
-    colgroup: string;
-    data: string;
-    datalist: string;
-    dd: string;
-    del: string;
-    details: string;
-    dfn: string;
-    dialog: string;
-    dir: string;
-    div: string;
-    dl: string;
-    dt: string;
-    em: string;
-    embed: string;
-    fieldset: string;
-    figcaption: string;
-    figure: string;
-    font: string;
-    footer: string;
-    form: string;
-    frame: string;
-    frameset: string;
-    h1: string;
-    h2: string;
-    h3: string;
-    h4: string;
-    h5: string;
-    h6: string;
-    head: string;
-    header: string;
-    hgroup: string;
-    hr: string;
-    html: string;
-    i: string;
-    iframe: string;
-    img: string;
-    input: string;
-    ins: string;
-    kbd: string;
-    label: string;
-    legend: string;
-    li: string;
-    link: string;
-    main: string;
-    map: string;
-    mark: string;
-    marquee: string;
-    menu: string;
-    meta: string;
-    meter: string;
-    nav: string;
-    noscript: string;
-    object: string;
-    ol: string;
-    optgroup: string;
-    option: string;
-    output: string;
-    p: string;
-    param: string;
-    picture: string;
-    pre: string;
-    progress: string;
-    q: string;
-    rp: string;
-    rt: string;
-    ruby: string;
-    s: string;
-    samp: string;
-    script: string;
-    search: string;
-    section: string;
-    select: string;
-    slot: string;
-    small: string;
-    source: string;
-    span: string;
-    strong: string;
-    style: string;
-    sub: string;
-    summary: string;
-    sup: string;
-    table: string;
-    tbody: string;
-    td: string;
-    template: string;
-    textarea: string;
-    tfoot: string;
-    th: string;
-    thead: string;
-    time: string;
-    title: string;
-    tr: string;
-    track: string;
-    u: string;
-    ul: string;
-    var: string;
-    video: string;
-    wbr: string;
-};
-type ElementTag = keyof typeof tag_map;
-export declare function isElementTag(element: string): element is ElementTag;
-/**
- * Returns the DOM interface for a tag, or `HTMLElement` when unknown.
- *
- * @example
- * ```ts
- * getElementByTag("button")  // Returns: "HTMLButtonElement"
- * getElementByTag("div")     // Returns: "HTMLDivElement"
- * getElementByTag("custom")  // Returns: "HTMLElement" (fallback)
- * ```
- */
-export declare function getElementByTag(element: string): string;
-export {};

package/lib/example-check.d.ts

@@ -1,24 +0,0 @@
-import type { ParsedComponent, SourceRange } from "./ComponentParser";
-/**
- * One `@example` block worth type-checking, reduced to what `resolve-types.ts`
- * needs: a declaration for the documented symbol and the example body itself.
- */
-export interface ExampleCheckSource {
-    /** Stable id for diagnostics, e.g. `"prop:variant"` or `"prop:variant#1"` for a second example. */
-    id: string;
-    /** Human-readable name shown in diagnostics, e.g. `"variant"` or `"variant (example 2)"`. */
-    name: string;
-    /** TypeScript type to bind the documented symbol to before running `code`. */
-    type: string;
-    /** The `@example` body, stripped of any surrounding code fence. */
-    code: string;
-    /** Source range of the documented symbol (prop/export/slot/event), when available. */
-    source?: SourceRange;
-}
-/**
- * Collects every `@example` block sveld can type-check for a parsed component:
- * plain TS/JS bodies on props, module exports, slots, and events. Svelte/HTML
- * markup examples (most slot/event examples, many prop examples) are skipped.
- * Checking those needs `svelte2tsx` or similar; sveld stays AST-only.
- */
-export declare function collectExampleSources(component: ParsedComponent): ExampleCheckSource[];

package/lib/get-svelte-entry.d.ts

@@ -1,4 +0,0 @@
-import { type SvelteEntryPoint } from "./brands";
-export type { SvelteEntryPoint };
-/** Resolve the Svelte entry from `entryPoint` or `package.json#svelte`. */
-export declare function getSvelteEntry(entryPoint?: string): SvelteEntryPoint | null;

package/lib/load-config.d.ts

@@ -1,62 +0,0 @@
-import type { PluginSveldOptions } from "./plugin";
-/**
- * Options shared by the config file, the CLI, and the programmatic `sveld()`
- * API. Superset of `PluginSveldOptions` with the CLI-oriented flags that only
- * make sense as part of a full `sveld` run (not the Vite/Rollup plugin).
- */
-export interface SveldRuntimeOptions extends PluginSveldOptions {
-    /** Print unresolved-type diagnostics to stderr. */
-    reportDiagnostics?: boolean;
-    /** Exit code 1 when diagnostics exist. Implies `reportDiagnostics`. */
-    strict?: boolean;
-    /**
-     * Diff the parsed component API against a committed snapshot (default:
-     * the `json` writer's `outFile`, or `COMPONENT_API.json`) and assign a
-     * semver bump to each change. Exits `1` on a breaking change. Pass a
-     * string for a custom snapshot path.
-     */
-    check?: boolean | string;
-}
-/**
- * Public shape of a `sveld.config.{js,ts,mjs}` file. Identical to the options
- * accepted by the CLI and the programmatic `sveld()` API.
- */
-export type SveldConfig = SveldRuntimeOptions;
-/** Config file names probed at the project root. First existing file wins. */
-export declare const CONFIG_FILE_NAMES: readonly ["sveld.config.js", "sveld.config.mjs", "sveld.config.ts"];
-/**
- * Identity helper that fully types a `sveld` config object.
- *
- * @example
- * ```ts
- * // sveld.config.js
- * import { defineConfig } from "sveld";
- *
- * export default defineConfig({
- *   glob: true,
- *   json: true,
- *   markdown: true,
- * });
- * ```
- */
-export declare function defineConfig(config: SveldConfig): SveldConfig;
-/** Locate a `sveld.config.{js,mjs,ts}` file in `cwd`, or `null` if none exists. */
-export declare function resolveConfigPath(cwd?: string): string | null;
-/**
- * Load and validate a `sveld` config file by absolute path.
- *
- * The package is ESM-only, so the file is loaded via dynamic `import()`. A
- * cache-busting query is appended so repeated loads (e.g. across tests or
- * watch runs) reflect the latest contents.
- *
- * @throws if the module cannot be imported (e.g. a syntax error or a config
- * that throws at evaluation time) or if it does not default-export an object.
- */
-export declare function loadConfigFrom(configPath: string): Promise<SveldConfig>;
-/**
- * Discover and load a `sveld.config.{js,mjs,ts}` file from `cwd`.
- * Returns an empty object when no config file is present.
- */
-export declare function loadConfig(cwd?: string): Promise<SveldConfig>;
-/** Shallow-merge option sources. Later sources override earlier ones. */
-export declare function mergeConfig<T extends PluginSveldOptions = PluginSveldOptions>(...sources: Array<Partial<T> | undefined>): Partial<T>;

package/lib/parse-cache.d.ts

@@ -1,28 +0,0 @@
-import { type ParsedComponent } from "./ComponentParser";
-/** Default on-disk location for the persistent parse cache, relative to the project root. */
-export declare const DEFAULT_CACHE_FILE: string;
-/** Resolves the effective cache file path for `cache: true | string`. */
-export declare function resolveCacheFilePath(rootDir: string, cache: boolean | string): string;
-export declare function hashSource(source: string): string;
-/**
- * Cross-run parse cache. Entries match on file path and sha256 of source.
- * Symbol-keyed TypeScript metadata is stored separately because JSON drops symbols.
- */
-export declare class ParseCache {
-    private readonly cacheFilePath;
-    private readonly file;
-    private readonly next;
-    /** Paths forced to miss this run (e.g. dependents of a changed `@extends` target). */
-    private readonly blocked;
-    constructor(cacheFilePath: string);
-    /** True when `get()` would return a hit for `resolvedPath` and `hash`. */
-    has(resolvedPath: string, hash: string): boolean;
-    /** Returns the cached parse for `resolvedPath` when its content hash still matches. */
-    get(resolvedPath: string, hash: string): ParsedComponent | null;
-    /** Records a freshly parsed component so it can be reused on a future run. */
-    set(resolvedPath: string, hash: string, parsed: ParsedComponent): void;
-    /** Skip cache for `resolvedPath` this run (e.g. an @extends dependent). */
-    invalidate(resolvedPath: string): void;
-    /** Persists this run's cache entries back to disk. */
-    save(): void;
-}

package/lib/parse-entry-exports.d.ts

@@ -1,30 +0,0 @@
-/** One named export from the entry barrel (not a `.svelte` component). */
-export interface EntryExport {
-    name: string;
-    kind: "const" | "let" | "var" | "function" | "class" | "type" | "interface" | "enum";
-    /** Type text from the source, when present. */
-    type?: string;
-    /** Initializer text for simple constants. */
-    value?: string;
-    description?: string;
-    /** Declaring module, relative to the entry file. */
-    source?: string;
-    isTypeOnly: boolean;
-}
-export type EntryExports = EntryExport[];
-/**
- * List consts, functions, and types exported from an entry barrel.
- *
- * Follows re-exports with AST-only traversal. Skips `.svelte` files.
- *
- * @param entryFile - Absolute path to the entry module.
- * @returns Exports deduplicated by name, sorted alphabetically.
- *
- * @example
- * ```ts
- * // entry: export { VERSION } from "./constants"; export type { Theme } from "./types";
- * parseEntryExports("/abs/src/index.ts");
- * // [{ name: "Theme", kind: "type", isTypeOnly: true, ... }, { name: "VERSION", kind: "const", ... }]
- * ```
- */
-export declare function parseEntryExports(entryFile: string): EntryExports;