svelte-shaker 0.9.2 → 0.10.0

package/dist/analyze.d.ts

@@ -3,6 +3,11 @@ import { type AnalyzeInput, type ComponentId, type ComponentPlan, type Literal }
 import { type Span } from './dead.js';
 export type Resolve = (source: string, importer: ComponentId) => Promise<ComponentId | null> | ComponentId | null;
 export type ReadFile = (id: ComponentId) => Promise<string> | string;
+/** Synchronous variants of {@link Resolve}/{@link ReadFile} for callers that
+ * cannot await — e.g. an ESLint rule, which runs synchronously. Used by
+ * {@link buildAnalyzeInputSync}. */
+export type ResolveSync = (source: string, importer: ComponentId) => ComponentId | null;
+export type ReadFileSync = (id: ComponentId) => string;
 /** One declared prop in a `$props()` destructuring. */
 export interface PropDecl {
     /** The EXTERNAL prop name — the destructure KEY (`prop` in `prop: alias`).
@@ -148,12 +153,50 @@ export declare function analyzeInput(input: AnalyzeInput, parseCache?: ParseCach
  * value set), keeping the produced model set — and thus the output — identical.
  */
 export declare function buildAnalyzeInput(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, parseCache?: ParseCache, parse?: Parse): Promise<AnalyzeInput>;
+/**
+ * Synchronous twin of {@link buildAnalyzeInput} for callers that cannot await
+ * (an ESLint rule runs synchronously). Byte-for-byte the same crawl with sync
+ * `resolve`/`readFile`; the `tests/build-analyze-input-sync` differential test
+ * pins it identical to the async path, so keep the two bodies in lockstep.
+ */
+export declare function buildAnalyzeInputSync(entries: ComponentId | ComponentId[], resolve: ResolveSync, readFile: ReadFileSync, parseCache?: ParseCache, parse?: Parse): AnalyzeInput;
 /**
  * Dead `{#if}` spans per component implied by `plans`, via the SAME shared
  * predicate the transform uses ({@link computeDeadSpans}).  A bailed component
  * folds nothing, so it has no dead spans.
  */
 export declare function deadSpansForPlans(models: Map<ComponentId, FileModel>, plans: Map<ComponentId, ComponentPlan>): Map<ComponentId, Span[]>;
+/** One declared prop that no call site in the program ever passes. `start`/`end`
+ * are UTF-16 offsets of the prop's `$props()` destructuring property, for direct
+ * source mapping by a consumer (e.g. an ESLint rule). */
+export interface UnpassedProp {
+    /** The external prop name (what a caller would pass). */
+    name: string;
+    start: number;
+    end: number;
+}
+/**
+ * Declared props that NO call site in the analyzed program ever passes — neither
+ * explicitly (`<C p=…>` / `bind:p`), via a spread, nor as body content/`{#snippet}`.
+ * These are "dead" from the consumer side: the component declares an input no one
+ * supplies, so it is always its default. A lint-oriented counterpart to the
+ * build-time fold (svelte-shaker would const-fold such a prop to its default).
+ *
+ * Soundness — only HIGH-CONFIDENCE reports, mirroring the folder's own caution:
+ *  - a component that BAILED (escaped as a value, `accessors`, etc.) is skipped —
+ *    its prop profile is unknowable;
+ *  - a component with ZERO call sites is skipped — it is an entry/route/unused
+ *    component whose props may be supplied OUTSIDE the analyzed graph (a SvelteKit
+ *    `+page.svelte`'s `data`, a framework mount, a not-yet-rendered component);
+ *  - a prop is reported only when EVERY call site neither names it nor carries a
+ *    spread that could set it (`readCallSite` already folds `bind:`, known
+ *    spreads, and `children`/snippet body into `explicit`/`hadSpread`).
+ *
+ * Because missing an edge (e.g. an unfollowed barrel) only DROPS call sites, it
+ * can only make this UNDER-report (the component looks unused and is skipped),
+ * never over-report — so an incomplete crawl stays false-positive-free.
+ */
+export declare function findNeverPassedProps(input: AnalyzeInput): Map<ComponentId, UnpassedProp[]>;
 /**
  * Remap a plan map keyed by EXTERNAL prop name (`constFold` / `narrow`) to one
  * keyed by the LOCAL binding name each prop introduces.  Call-site analysis and

package/dist/analyze.js

@@ -174,6 +174,72 @@ export async function buildAnalyzeInput(entries, resolve, readFile, parseCache,
     }
     return { files, edges, entries: entryList };
 }
+/**
+ * Synchronous twin of {@link buildAnalyzeInput} for callers that cannot await
+ * (an ESLint rule runs synchronously). Byte-for-byte the same crawl with sync
+ * `resolve`/`readFile`; the `tests/build-analyze-input-sync` differential test
+ * pins it identical to the async path, so keep the two bodies in lockstep.
+ */
+export function buildAnalyzeInputSync(entries, resolve, readFile, parseCache, parse) {
+    const entryList = Array.isArray(entries) ? [...entries] : [entries];
+    const files = [];
+    const edges = [];
+    const queue = [...entryList];
+    const seen = new Set(queue);
+    while (queue.length > 0) {
+        const id = queue.shift();
+        const code = readFile(id);
+        files.push({ id, code });
+        const ast = parseCached(id, code, parseCache, parse);
+        const instance = ast.instance;
+        if (!instance)
+            continue;
+        const barrelLocals = new Map();
+        const namespaceSources = new Map();
+        const directChildren = [];
+        for (const imp of importSources(instance)) {
+            if (imp.imported === '*') {
+                namespaceSources.set(imp.local, imp.value);
+                continue;
+            }
+            if (imp.imported === 'default' && isSvelte(imp.value)) {
+                const childId = resolve(imp.value, id);
+                if (childId) {
+                    edges.push({ from: id, local: imp.local, to: childId, kind: 'default-svelte' });
+                    directChildren.push(childId);
+                }
+                continue;
+            }
+            const childId = resolveThroughBarrelSync(imp.value, imp.imported, id, resolve, readFile);
+            if (childId) {
+                edges.push({ from: id, local: imp.local, to: childId, kind: 'barrel' });
+                barrelLocals.set(imp.local, childId);
+            }
+        }
+        const nsChildren = [];
+        if (namespaceSources.size > 0) {
+            for (const tag of memberComponentTags(ast)) {
+                const dot = tag.indexOf('.');
+                const source = namespaceSources.get(tag.slice(0, dot));
+                if (source == null)
+                    continue;
+                const childId = resolveThroughBarrelSync(source, tag.slice(dot + 1), id, resolve, readFile);
+                if (childId) {
+                    edges.push({ from: id, local: tag, to: childId, kind: 'namespace' });
+                    nsChildren.push(childId);
+                }
+            }
+        }
+        const rendered = collectBarrelChildIds(ast, barrelLocals);
+        for (const childId of [...directChildren, ...rendered, ...nsChildren]) {
+            if (!seen.has(childId)) {
+                seen.add(childId);
+                queue.push(childId);
+            }
+        }
+    }
+    return { files, edges, entries: entryList };
+}
 /**
  * Aggregate every component's call sites into per-child {@link Usage}, EXCLUDING
  * any `<Child/>` whose node falls inside a dead `{#if}` span of its containing
@@ -279,6 +345,67 @@ export function deadSpansForPlans(models, plans) {
     }
     return out;
 }
+/**
+ * Declared props that NO call site in the analyzed program ever passes — neither
+ * explicitly (`<C p=…>` / `bind:p`), via a spread, nor as body content/`{#snippet}`.
+ * These are "dead" from the consumer side: the component declares an input no one
+ * supplies, so it is always its default. A lint-oriented counterpart to the
+ * build-time fold (svelte-shaker would const-fold such a prop to its default).
+ *
+ * Soundness — only HIGH-CONFIDENCE reports, mirroring the folder's own caution:
+ *  - a component that BAILED (escaped as a value, `accessors`, etc.) is skipped —
+ *    its prop profile is unknowable;
+ *  - a component with ZERO call sites is skipped — it is an entry/route/unused
+ *    component whose props may be supplied OUTSIDE the analyzed graph (a SvelteKit
+ *    `+page.svelte`'s `data`, a framework mount, a not-yet-rendered component);
+ *  - a prop is reported only when EVERY call site neither names it nor carries a
+ *    spread that could set it (`readCallSite` already folds `bind:`, known
+ *    spreads, and `children`/snippet body into `explicit`/`hadSpread`).
+ *
+ * Because missing an edge (e.g. an unfollowed barrel) only DROPS call sites, it
+ * can only make this UNDER-report (the component looks unused and is skipped),
+ * never over-report — so an incomplete crawl stays false-positive-free.
+ */
+export function findNeverPassedProps(input) {
+    const models = buildModels(input);
+    // Stamp escape bails up front (same union as `analyzeInput`) so escaped
+    // components are skipped below.
+    const escaped = new Set();
+    for (const model of models.values())
+        for (const id of model.escapedComponents)
+            escaped.add(id);
+    for (const id of escaped) {
+        const model = models.get(id);
+        if (model && !model.bailReasons.includes(ESCAPE_REASON))
+            model.bailReasons.push(ESCAPE_REASON);
+    }
+    // Every textual call site counts (no cascade dead-span filtering): a prop passed
+    // only at a folded-away site is still author-written, so we do not flag it.
+    const usage = buildUsage(models, new Map());
+    const out = new Map();
+    for (const model of models.values()) {
+        if (model.bailReasons.length > 0)
+            continue;
+        if (!model.props || model.props.length === 0)
+            continue;
+        const sites = usage.get(model.id)?.sites ?? [];
+        if (sites.length === 0)
+            continue;
+        const unpassed = [];
+        for (const decl of model.props) {
+            const maybePassed = sites.some((s) => s.explicit.has(decl.name) || s.hadSpread);
+            if (maybePassed)
+                continue;
+            const prop = decl.property;
+            if (typeof prop.start !== 'number' || typeof prop.end !== 'number')
+                continue;
+            unpassed.push({ name: decl.name, start: prop.start, end: prop.end });
+        }
+        if (unpassed.length > 0)
+            out.set(model.id, unpassed);
+    }
+    return out;
+}
 /**
  * Remap a plan map keyed by EXTERNAL prop name (`constFold` / `narrow`) to one
  * keyed by the LOCAL binding name each prop introduces.  Call-site analysis and
@@ -1103,6 +1230,58 @@ async function resolveThroughBarrel(source, imported, importer, resolve, readFil
     }
     return null;
 }
+/** Synchronous twin of {@link resolveThroughBarrel} (see {@link
+ * buildAnalyzeInputSync}). Keep in lockstep with the async body above. */
+function resolveThroughBarrelSync(source, imported, importer, resolve, readFile, hops = 0) {
+    if (hops > MAX_BARREL_HOPS)
+        return null;
+    const targetId = resolve(source, importer);
+    if (!targetId)
+        return null;
+    if (isSvelte(source) || isSvelte(targetId)) {
+        return imported === 'default' || imported === '*' ? targetId : null;
+    }
+    let code;
+    try {
+        code = readFile(targetId);
+    }
+    catch {
+        return null;
+    }
+    const body = parseModuleBody(code, targetId);
+    if (!body)
+        return null;
+    for (const stmt of body) {
+        if (stmt.type === 'ExportNamedDeclaration' && stmt.source?.value) {
+            for (const spec of stmt.specifiers ?? []) {
+                if (specName(spec.exported) !== imported)
+                    continue;
+                return resolveThroughBarrelSync(String(stmt.source.value), specName(spec.local) ?? 'default', targetId, resolve, readFile, hops + 1);
+            }
+            continue;
+        }
+        if (stmt.type === 'ExportNamedDeclaration' && !stmt.source) {
+            for (const spec of stmt.specifiers ?? []) {
+                if (specName(spec.exported) !== imported)
+                    continue;
+                const localName = specName(spec.local);
+                if (!localName)
+                    continue;
+                const found = followLocalImport(body, localName);
+                if (!found)
+                    return null;
+                return resolveThroughBarrelSync(found.value, found.imported, targetId, resolve, readFile, hops + 1);
+            }
+            continue;
+        }
+        if (stmt.type === 'ExportAllDeclaration' && stmt.source?.value) {
+            const via = resolveThroughBarrelSync(String(stmt.source.value), imported, targetId, resolve, readFile, hops + 1);
+            if (via)
+                return via;
+        }
+    }
+    return null;
+}
 /** Find the import in `body` that binds `localName`, as an {@link ImportInfo}. */
 function followLocalImport(body, localName) {
     for (const stmt of body) {

package/dist/index.d.ts

@@ -3,9 +3,10 @@ import { type Parse } from './parse.js';
 import { type MonomorphizeOptions, type MonomorphizeResult } from './mono.js';
 import type { ComponentId } from './ir.js';
 export type { ComponentId, AnalyzeInput, InputFile, ResolvedEdge, EdgeKind, EditResult, } from './ir.js';
-export type { Resolve, ReadFile } from './analyze.js';
+export type { Resolve, ReadFile, ResolveSync, ReadFileSync } from './analyze.js';
 export type { Parse, Root } from './parse.js';
-export { analyze, analyzeInput, buildAnalyzeInput } from './analyze.js';
+export { analyze, analyzeInput, buildAnalyzeInput, buildAnalyzeInputSync, deadSpansForPlans, findNeverPassedProps, } from './analyze.js';
+export type { UnpassedProp } from './analyze.js';
 export { DevShaker, type DevMode, type DevShakerChange } from './engine.js';
 export { transformAll, transformAllWithMono } from './transform.js';
 export { monomorphize, DEFAULT_MONO_OPTIONS, type MonomorphizeOptions, type MonomorphizeResult, type Variant, type CallSiteBinding, } from './mono.js';

package/dist/index.js

@@ -2,7 +2,7 @@ import { analyze, analyzeInput, buildAnalyzeInput, } from './analyze.js';
 import { parseSvelte } from './parse.js';
 import { transformAll, transformAllWithMono } from './transform.js';
 import { monomorphize, DEFAULT_MONO_OPTIONS, } from './mono.js';
-export { analyze, analyzeInput, buildAnalyzeInput } from './analyze.js';
+export { analyze, analyzeInput, buildAnalyzeInput, buildAnalyzeInputSync, deadSpansForPlans, findNeverPassedProps, } from './analyze.js';
 export { DevShaker } from './engine.js';
 export { transformAll, transformAllWithMono } from './transform.js';
 export { monomorphize, DEFAULT_MONO_OPTIONS, } from './mono.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-shaker",
-  "version": "0.9.2",
+  "version": "0.10.0",
   "description": "Tree shaking for Svelte components",
   "keywords": [
     "dead-code-elimination",