@fuzdev/fuz_ui 0.194.0 → 0.195.1

package/dist/analysis_context.d.ts

@@ -1,199 +0,0 @@
-/**
- * Diagnostic collection for source analysis.
- *
- * Provides structured error/warning collection during TypeScript and Svelte
- * analysis, replacing silent catch blocks with actionable diagnostics.
- *
- * ## Error Handling Contract
- *
- * Analysis functions follow a two-tier error model:
- *
- * **Accumulated (non-fatal)** - Collected in `AnalysisContext`, analysis continues:
- * - Type resolution failures (complex generics, circular refs)
- * - Missing or unparseable JSDoc
- * - Individual member/prop extraction failures
- * - The return value is still valid but may have partial data
- *
- * **Thrown (fatal)** - Analysis cannot continue for this file:
- * - File not found or unreadable
- * - Syntax errors preventing parsing
- * - svelte2tsx transformation failures
- * - Svelte version incompatibility
- *
- * ## Usage Pattern
- *
- * ```ts
- * const ctx = new AnalysisContext();
- * const results = files.map(f => {
- *   try {
- *     return library_analyze_module(f, program, options, ctx);
- *   } catch (e) {
- *     // Fatal error - log and skip this file
- *     console.error(`Failed to analyze ${f.id}: ${e}`);
- *     return null;
- *   }
- * });
- *
- * // Results are valid even with accumulated errors
- * // Check ctx for diagnostics to display to user
- * if (ctx.has_errors()) {
- *   for (const err of ctx.errors()) {
- *     console.error(format_diagnostic(err));
- *   }
- * }
- * ```
- *
- * @example
- * ```ts
- * const ctx = new AnalysisContext();
- * // ... analysis functions add diagnostics via ctx.add(...)
- * if (ctx.has_errors()) {
- *   for (const err of ctx.errors()) {
- *     console.error(`${err.file}:${err.line}: ${err.message}`);
- *   }
- * }
- * ```
- *
- * @module
- */
-/**
- * Diagnostic severity levels.
- *
- * - `error`: Analysis failed, declaration may be incomplete or missing data
- * - `warning`: Partial success, something seems off but analysis continued
- */
-export type DiagnosticSeverity = 'error' | 'warning';
-/**
- * Discriminant for diagnostic types.
- */
-export type DiagnosticKind = 'type_extraction_failed' | 'signature_analysis_failed' | 'class_member_failed' | 'svelte_prop_failed' | 'module_skipped';
-/**
- * Base diagnostic fields shared by all diagnostic types.
- */
-export interface BaseDiagnostic {
-    kind: DiagnosticKind;
-    /** File path relative to project root (display with './' prefix). */
-    file: string;
-    /** Line number (1-based), or null if location unavailable. */
-    line: number | null;
-    /** Column number (1-based), or null if location unavailable. */
-    column: number | null;
-    /** Human-readable description of the issue. */
-    message: string;
-    severity: DiagnosticSeverity;
-}
-/**
- * Type extraction failed (e.g., complex or recursive types).
- */
-export interface TypeExtractionDiagnostic extends BaseDiagnostic {
-    kind: 'type_extraction_failed';
-    /** Name of the symbol whose type couldn't be extracted. */
-    symbol_name: string;
-}
-/**
- * Function/method signature analysis failed.
- */
-export interface SignatureAnalysisDiagnostic extends BaseDiagnostic {
-    kind: 'signature_analysis_failed';
-    /** Name of the function or method. */
-    function_name: string;
-}
-/**
- * Class member analysis failed.
- */
-export interface ClassMemberDiagnostic extends BaseDiagnostic {
-    kind: 'class_member_failed';
-    /** Name of the class. */
-    class_name: string;
-    /** Name of the member that failed. */
-    member_name: string;
-}
-/**
- * Svelte prop type resolution failed.
- */
-export interface SveltePropDiagnostic extends BaseDiagnostic {
-    kind: 'svelte_prop_failed';
-    /** Name of the component. */
-    component_name: string;
-    /** Name of the prop. */
-    prop_name: string;
-}
-/**
- * Module was skipped during analysis.
- * Could be due to missing source file in program or no analyzer available.
- */
-export interface ModuleSkippedDiagnostic extends BaseDiagnostic {
-    kind: 'module_skipped';
-    /** Reason the module was skipped. */
-    reason: 'not_in_program' | 'no_analyzer';
-}
-/**
- * Union of all diagnostic types.
- */
-export type Diagnostic = TypeExtractionDiagnostic | SignatureAnalysisDiagnostic | ClassMemberDiagnostic | SveltePropDiagnostic | ModuleSkippedDiagnostic;
-/**
- * Context for collecting diagnostics during source analysis.
- *
- * Thread an instance through analysis functions to collect errors and warnings
- * without halting analysis. After analysis completes, check `has_errors()` and
- * report collected diagnostics.
- *
- * @example
- * ```ts
- * const ctx = new AnalysisContext();
- * ts_analyze_module_exports(source_file, checker, options, ctx);
- * if (ctx.has_errors()) {
- *   console.error('Analysis completed with errors:');
- *   for (const d of ctx.errors()) {
- *     console.error(format_diagnostic(d));
- *   }
- * }
- * ```
- */
-export declare class AnalysisContext {
-    readonly diagnostics: Array<Diagnostic>;
-    /**
-     * Add a `Diagnostic` to the collection.
-     */
-    add(diagnostic: Diagnostic): void;
-    /**
-     * Check if any errors were collected.
-     */
-    has_errors(): boolean;
-    /**
-     * Check if any warnings were collected.
-     */
-    has_warnings(): boolean;
-    /**
-     * Get all error diagnostics.
-     */
-    errors(): Array<Diagnostic>;
-    /**
-     * Get all warning diagnostics.
-     */
-    warnings(): Array<Diagnostic>;
-    /**
-     * Get diagnostics of a specific `DiagnosticKind`.
-     */
-    by_kind<K extends DiagnosticKind>(kind: K): Array<Extract<Diagnostic, {
-        kind: K;
-    }>>;
-}
-/**
- * Options for formatting diagnostics.
- */
-export interface FormatDiagnosticOptions {
-    /** Prefix for file path (default: './'). */
-    prefix?: string;
-    /** Base path to strip from absolute file paths (e.g., process.cwd()). */
-    strip_base?: string;
-}
-/**
- * Format a diagnostic for display.
- *
- * @param diagnostic - the diagnostic to format
- * @param options - formatting options
- * @returns formatted string like './file.ts:10:5: error: message'
- */
-export declare const format_diagnostic: (diagnostic: Diagnostic, options?: FormatDiagnosticOptions) => string;
-//# sourceMappingURL=analysis_context.d.ts.map

package/dist/analysis_context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analysis_context.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/analysis_context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,cAAc,GACvB,wBAAwB,GACxB,2BAA2B,GAC3B,qBAAqB,GACrB,oBAAoB,GACpB,gBAAgB,CAAC;AAEpB;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,IAAI,EAAE,cAAc,CAAC;IACrB,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,gEAAgE;IAChE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,kBAAkB,CAAC;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,cAAc;IAC/D,IAAI,EAAE,wBAAwB,CAAC;IAC/B,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,2BAA4B,SAAQ,cAAc;IAClE,IAAI,EAAE,2BAA2B,CAAC;IAClC,sCAAsC;IACtC,aAAa,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAsB,SAAQ,cAAc;IAC5D,IAAI,EAAE,qBAAqB,CAAC;IAC5B,yBAAyB;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,cAAc;IAC3D,IAAI,EAAE,oBAAoB,CAAC;IAC3B,6BAA6B;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,wBAAwB;IACxB,SAAS,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,uBAAwB,SAAQ,cAAc;IAC9D,IAAI,EAAE,gBAAgB,CAAC;IACvB,qCAAqC;IACrC,MAAM,EAAE,gBAAgB,GAAG,aAAa,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,MAAM,UAAU,GACnB,wBAAwB,GACxB,2BAA2B,GAC3B,qBAAqB,GACrB,oBAAoB,GACpB,uBAAuB,CAAC;AAE3B;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,eAAe;IAC3B,QAAQ,CAAC,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,CAAM;IAE7C;;OAEG;IACH,GAAG,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAIjC;;OAEG;IACH,UAAU,IAAI,OAAO;IAIrB;;OAEG;IACH,YAAY,IAAI,OAAO;IAIvB;;OAEG;IACH,MAAM,IAAI,KAAK,CAAC,UAAU,CAAC;IAI3B;;OAEG;IACH,QAAQ,IAAI,KAAK,CAAC,UAAU,CAAC;IAI7B;;OAEG;IACH,OAAO,CAAC,CAAC,SAAS,cAAc,EAAE,IAAI,EAAE,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,UAAU,EAAE;QAAC,IAAI,EAAE,CAAC,CAAA;KAAC,CAAC,CAAC;CAGjF;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACvC,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,GAC7B,YAAY,UAAU,EACtB,UAAU,uBAAuB,KAC/B,MAeF,CAAC"}

package/dist/analysis_context.js

@@ -1,138 +0,0 @@
-/**
- * Diagnostic collection for source analysis.
- *
- * Provides structured error/warning collection during TypeScript and Svelte
- * analysis, replacing silent catch blocks with actionable diagnostics.
- *
- * ## Error Handling Contract
- *
- * Analysis functions follow a two-tier error model:
- *
- * **Accumulated (non-fatal)** - Collected in `AnalysisContext`, analysis continues:
- * - Type resolution failures (complex generics, circular refs)
- * - Missing or unparseable JSDoc
- * - Individual member/prop extraction failures
- * - The return value is still valid but may have partial data
- *
- * **Thrown (fatal)** - Analysis cannot continue for this file:
- * - File not found or unreadable
- * - Syntax errors preventing parsing
- * - svelte2tsx transformation failures
- * - Svelte version incompatibility
- *
- * ## Usage Pattern
- *
- * ```ts
- * const ctx = new AnalysisContext();
- * const results = files.map(f => {
- *   try {
- *     return library_analyze_module(f, program, options, ctx);
- *   } catch (e) {
- *     // Fatal error - log and skip this file
- *     console.error(`Failed to analyze ${f.id}: ${e}`);
- *     return null;
- *   }
- * });
- *
- * // Results are valid even with accumulated errors
- * // Check ctx for diagnostics to display to user
- * if (ctx.has_errors()) {
- *   for (const err of ctx.errors()) {
- *     console.error(format_diagnostic(err));
- *   }
- * }
- * ```
- *
- * @example
- * ```ts
- * const ctx = new AnalysisContext();
- * // ... analysis functions add diagnostics via ctx.add(...)
- * if (ctx.has_errors()) {
- *   for (const err of ctx.errors()) {
- *     console.error(`${err.file}:${err.line}: ${err.message}`);
- *   }
- * }
- * ```
- *
- * @module
- */
-/**
- * Context for collecting diagnostics during source analysis.
- *
- * Thread an instance through analysis functions to collect errors and warnings
- * without halting analysis. After analysis completes, check `has_errors()` and
- * report collected diagnostics.
- *
- * @example
- * ```ts
- * const ctx = new AnalysisContext();
- * ts_analyze_module_exports(source_file, checker, options, ctx);
- * if (ctx.has_errors()) {
- *   console.error('Analysis completed with errors:');
- *   for (const d of ctx.errors()) {
- *     console.error(format_diagnostic(d));
- *   }
- * }
- * ```
- */
-export class AnalysisContext {
-    diagnostics = [];
-    /**
-     * Add a `Diagnostic` to the collection.
-     */
-    add(diagnostic) {
-        this.diagnostics.push(diagnostic);
-    }
-    /**
-     * Check if any errors were collected.
-     */
-    has_errors() {
-        return this.diagnostics.some((d) => d.severity === 'error');
-    }
-    /**
-     * Check if any warnings were collected.
-     */
-    has_warnings() {
-        return this.diagnostics.some((d) => d.severity === 'warning');
-    }
-    /**
-     * Get all error diagnostics.
-     */
-    errors() {
-        return this.diagnostics.filter((d) => d.severity === 'error');
-    }
-    /**
-     * Get all warning diagnostics.
-     */
-    warnings() {
-        return this.diagnostics.filter((d) => d.severity === 'warning');
-    }
-    /**
-     * Get diagnostics of a specific `DiagnosticKind`.
-     */
-    by_kind(kind) {
-        return this.diagnostics.filter((d) => d.kind === kind);
-    }
-}
-/**
- * Format a diagnostic for display.
- *
- * @param diagnostic - the diagnostic to format
- * @param options - formatting options
- * @returns formatted string like './file.ts:10:5: error: message'
- */
-export const format_diagnostic = (diagnostic, options) => {
-    const prefix = options?.prefix ?? './';
-    const strip_base = options?.strip_base;
-    let file = diagnostic.file;
-    if (strip_base && file.startsWith(strip_base)) {
-        file = file.slice(strip_base.length);
-        // Remove leading slash if present
-        if (file.startsWith('/'))
-            file = file.slice(1);
-    }
-    const { line, column, severity, message } = diagnostic;
-    const location = line !== null ? (column !== null ? `${line}:${column}` : `${line}`) : '';
-    const file_part = location ? `${prefix}${file}:${location}` : `${prefix}${file}`;
-    return `${file_part}: ${severity}: ${message}`;
-};

package/dist/library_analysis.d.ts

@@ -1,112 +0,0 @@
-/**
- * Library source analysis - unified entry point and shared types.
- *
- * Provides a single function for analyzing TypeScript and Svelte source files,
- * dispatching to the appropriate domain-specific analyzer.
- *
- * This module also exports shared types used by both analyzers:
- * - `DeclarationAnalysis` - A declaration with its nodocs flag
- * - `ReExportInfo` - Information about a same-name re-export
- * - `ModuleAnalysis` - Result of analyzing a module (unified structure)
- *
- * @example
- * ```ts
- * import {library_analyze_module} from './library_analysis.js';
- * import {ts_create_program} from './ts_helpers.js';
- * import {module_create_source_options} from './module_helpers.js';
- * import {AnalysisContext} from './analysis_context.js';
- *
- * const {program} = ts_create_program({root: './my-project'});
- * const ctx = new AnalysisContext();
- * const options = module_create_source_options('/my-project');
- *
- * const result = library_analyze_module(
- *   {id: '/my-project/src/lib/file.ts', content: '...'},
- *   program,
- *   options,
- *   ctx,
- * );
- *
- * if (result) {
- *   // Filter out @nodocs declarations
- *   const declarations = result.declarations
- *     .filter(d => !d.nodocs)
- *     .map(d => d.declaration);
- *   console.log('Declarations:', declarations);
- * }
- * ```
- *
- * @see `ts_helpers.ts` for TypeScript-specific analysis
- * @see `svelte_helpers.ts` for Svelte component analysis
- * @see `module_helpers.ts` for path utilities and `SourceFileInfo`
- *
- * @module
- */
-import ts from 'typescript';
-import type { Logger } from '@fuzdev/fuz_util/log.js';
-import type { DeclarationJson } from '@fuzdev/fuz_util/source_json.js';
-import { type SourceFileInfo, type ModuleSourceOptions } from './module_helpers.js';
-import type { AnalysisContext } from './analysis_context.js';
-/**
- * Result of analyzing a single declaration.
- * Used by both TypeScript and Svelte analyzers for uniform handling.
- */
-export interface DeclarationAnalysis {
-    /** The analyzed declaration metadata. */
-    declaration: DeclarationJson;
-    /** Whether the declaration is marked `@nodocs` (should be excluded from documentation). */
-    nodocs: boolean;
-}
-/**
- * Information about a same-name re-export.
- * Used for post-processing to build `also_exported_from` arrays.
- */
-export interface ReExportInfo {
-    /** Name of the re-exported declaration. */
-    name: string;
-    /** Module path (relative to src/lib) where the declaration is originally declared. */
-    original_module: string;
-}
-/**
- * Result of analyzing a module (TypeScript or Svelte).
- * Both analyzers return this same structure for uniform handling.
- */
-export interface ModuleAnalysis {
-    /** Module path relative to source root. */
-    path: string;
-    /** Module-level documentation comment. */
-    module_comment?: string;
-    /** All declarations with nodocs flags - consumer filters based on policy. */
-    declarations: Array<DeclarationAnalysis>;
-    /** Dependencies (other source modules this module imports). Empty if none. */
-    dependencies: Array<string>;
-    /** Dependents (other source modules that import this module). Empty if none. */
-    dependents: Array<string>;
-    /** Star exports (`export * from './module'`). Empty for Svelte components. */
-    star_exports: Array<string>;
-    /** Re-exports discovered during analysis. Empty for Svelte components. */
-    re_exports: Array<ReExportInfo>;
-}
-/**
- * Analyze a source file and extract module metadata.
- *
- * Unified entry point that dispatches to the appropriate analyzer based on file type:
- * - TypeScript/JS files → `ts_analyze_module`
- * - Svelte components → `svelte_analyze_module`
- *
- * Returns raw analysis data including `nodocs` flags on declarations.
- * Consumer is responsible for filtering based on their policy.
- *
- * This function can be called incrementally - consumers may cache results and
- * only re-analyze changed files. The TypeScript program should include all files
- * for accurate type resolution, but only changed files need re-analysis.
- *
- * @param source_file - the source file info with content and optional dependency data
- * @param program - TypeScript program (used for type checking and source file lookup)
- * @param options - module source options for path extraction
- * @param ctx - analysis context for collecting diagnostics
- * @param log - optional logger for warnings
- * @returns module metadata and re-exports, or undefined if source file not found in program
- */
-export declare const library_analyze_module: (source_file: SourceFileInfo, program: ts.Program, options: ModuleSourceOptions, ctx: AnalysisContext, log?: Logger) => ModuleAnalysis | undefined;
-//# sourceMappingURL=library_analysis.d.ts.map

package/dist/library_analysis.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"library_analysis.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/library_analysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,iCAAiC,CAAC;AAIrE,OAAO,EACN,KAAK,cAAc,EACnB,KAAK,mBAAmB,EAExB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAE3D;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IACnC,yCAAyC;IACzC,WAAW,EAAE,eAAe,CAAC;IAC7B,2FAA2F;IAC3F,MAAM,EAAE,OAAO,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC5B,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,sFAAsF;IACtF,eAAe,EAAE,MAAM,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,6EAA6E;IAC7E,YAAY,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACzC,8EAA8E;IAC9E,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC5B,gFAAgF;IAChF,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B,8EAA8E;IAC9E,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC5B,0EAA0E;IAC1E,UAAU,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,sBAAsB,GAClC,aAAa,cAAc,EAC3B,SAAS,EAAE,CAAC,OAAO,EACnB,SAAS,mBAAmB,EAC5B,KAAK,eAAe,EACpB,MAAM,MAAM,KACV,cAAc,GAAG,SAuCnB,CAAC"}

package/dist/library_analysis.js

@@ -1,106 +0,0 @@
-/**
- * Library source analysis - unified entry point and shared types.
- *
- * Provides a single function for analyzing TypeScript and Svelte source files,
- * dispatching to the appropriate domain-specific analyzer.
- *
- * This module also exports shared types used by both analyzers:
- * - `DeclarationAnalysis` - A declaration with its nodocs flag
- * - `ReExportInfo` - Information about a same-name re-export
- * - `ModuleAnalysis` - Result of analyzing a module (unified structure)
- *
- * @example
- * ```ts
- * import {library_analyze_module} from './library_analysis.js';
- * import {ts_create_program} from './ts_helpers.js';
- * import {module_create_source_options} from './module_helpers.js';
- * import {AnalysisContext} from './analysis_context.js';
- *
- * const {program} = ts_create_program({root: './my-project'});
- * const ctx = new AnalysisContext();
- * const options = module_create_source_options('/my-project');
- *
- * const result = library_analyze_module(
- *   {id: '/my-project/src/lib/file.ts', content: '...'},
- *   program,
- *   options,
- *   ctx,
- * );
- *
- * if (result) {
- *   // Filter out @nodocs declarations
- *   const declarations = result.declarations
- *     .filter(d => !d.nodocs)
- *     .map(d => d.declaration);
- *   console.log('Declarations:', declarations);
- * }
- * ```
- *
- * @see `ts_helpers.ts` for TypeScript-specific analysis
- * @see `svelte_helpers.ts` for Svelte component analysis
- * @see `module_helpers.ts` for path utilities and `SourceFileInfo`
- *
- * @module
- */
-import ts from 'typescript';
-import { ts_analyze_module } from './ts_helpers.js';
-import { svelte_analyze_module } from './svelte_helpers.js';
-import { module_extract_path, } from './module_helpers.js';
-/**
- * Analyze a source file and extract module metadata.
- *
- * Unified entry point that dispatches to the appropriate analyzer based on file type:
- * - TypeScript/JS files → `ts_analyze_module`
- * - Svelte components → `svelte_analyze_module`
- *
- * Returns raw analysis data including `nodocs` flags on declarations.
- * Consumer is responsible for filtering based on their policy.
- *
- * This function can be called incrementally - consumers may cache results and
- * only re-analyze changed files. The TypeScript program should include all files
- * for accurate type resolution, but only changed files need re-analysis.
- *
- * @param source_file - the source file info with content and optional dependency data
- * @param program - TypeScript program (used for type checking and source file lookup)
- * @param options - module source options for path extraction
- * @param ctx - analysis context for collecting diagnostics
- * @param log - optional logger for warnings
- * @returns module metadata and re-exports, or undefined if source file not found in program
- */
-export const library_analyze_module = (source_file, program, options, ctx, log) => {
-    const checker = program.getTypeChecker();
-    const module_path = module_extract_path(source_file.id, options);
-    const analyzer_type = options.get_analyzer(source_file.id);
-    if (analyzer_type === 'svelte') {
-        return svelte_analyze_module(source_file, module_path, checker, options, ctx);
-    }
-    if (analyzer_type === 'typescript') {
-        const ts_source_file = program.getSourceFile(source_file.id);
-        if (!ts_source_file) {
-            ctx.add({
-                kind: 'module_skipped',
-                file: module_path,
-                line: null,
-                column: null,
-                message: `Could not get source file from program: ${source_file.id}`,
-                severity: 'warning',
-                reason: 'not_in_program',
-            });
-            log?.warn(`Could not get source file from program: ${source_file.id}`);
-            return undefined;
-        }
-        return ts_analyze_module(source_file, ts_source_file, module_path, checker, options, ctx);
-    }
-    // analyzer_type is null - skip this file
-    ctx.add({
-        kind: 'module_skipped',
-        file: module_path,
-        line: null,
-        column: null,
-        message: `No analyzer for file type: ${source_file.id}`,
-        severity: 'warning',
-        reason: 'no_analyzer',
-    });
-    log?.warn(`No analyzer for file: ${source_file.id}`);
-    return undefined;
-};

package/dist/library_generate.d.ts

@@ -1,94 +0,0 @@
-/**
- * Generic library metadata generation.
- *
- * This module provides build-tool agnostic library generation. It takes source files
- * and package metadata, analyzes them, and produces structured metadata with:
- * - JSDoc/TSDoc comments with full tag support
- * - Full type signatures
- * - Source code locations
- * - Parameter information with descriptions and defaults
- * - Return value documentation
- * - Usage examples
- * - Dependency graphs
- * - Svelte component props
- *
- * For Gro integration, see `library_gen.ts` which wraps this with Gro's `Gen` interface.
- *
- * @see `@fuzdev/fuz_util/source_json.js` for type definitions
- * @see `library_analysis.ts` for the unified analysis entry point
- * @see `library_pipeline.ts` for pipeline helpers
- * @see `library_output.ts` for JSON/TS file generation
- *
- * @module
- */
-import type ts from 'typescript';
-import type { SourceJson } from '@fuzdev/fuz_util/source_json.js';
-import type { PackageJson } from '@fuzdev/fuz_util/package_json.js';
-import type { Logger } from '@fuzdev/fuz_util/log.js';
-import { type SourceFileInfo, type ModuleSourceOptions } from './module_helpers.js';
-import { type DuplicateInfo } from './library_pipeline.js';
-/**
- * Callback for handling duplicate declaration names.
- *
- * @param duplicates - map of declaration names to their occurrences across modules
- * @param log - logger for reporting
- */
-export type OnDuplicatesCallback = (duplicates: Map<string, Array<DuplicateInfo>>, log: {
-    error: (...args: Array<unknown>) => void;
-}) => void;
-/**
- * Strict duplicate handler that throws on any duplicate declaration names.
- *
- * Use this callback with `library_generate({ on_duplicates: library_throw_on_duplicates })`
- * to enforce a flat namespace where all declaration names must be unique.
- *
- * @throws Error if any duplicate declaration names are found
- */
-export declare const library_throw_on_duplicates: OnDuplicatesCallback;
-/** Input for library metadata generation. */
-export interface LibraryGenerateInput {
-    /** Source files to analyze (must have content loaded). */
-    source_files: Array<SourceFileInfo>;
-    /** Package metadata (name, version). */
-    package_json: PackageJson;
-    /** Module source options for path extraction. */
-    source_options: ModuleSourceOptions;
-    /**
-     * Optional TypeScript program. If not provided, one will be created.
-     * Pass an existing program to reuse across multiple calls.
-     */
-    program?: ts.Program;
-    /** Optional callback for handling duplicate declaration names. */
-    on_duplicates?: OnDuplicatesCallback;
-    /** Optional logger for status and diagnostic messages. */
-    log?: Logger;
-}
-/** Result of library metadata generation. */
-export interface LibraryGenerateResult {
-    /** The generated source metadata. */
-    source_json: SourceJson;
-    /** JSON file content string. */
-    json_content: string;
-    /** TypeScript wrapper file content string. */
-    ts_content: string;
-}
-/**
- * Generate library metadata from source files.
- *
- * This is the main entry point for library generation. It analyzes source files,
- * extracts metadata, and produces both structured data and file contents.
- *
- * @example
- * ```ts
- * const result = library_generate({
- *   source_files,
- *   package_json: {name: '@my/lib', version: '1.0.0'},
- *   source_options: module_create_source_options(process.cwd()),
- * });
- *
- * await writeFile('library.json', result.json_content);
- * await writeFile('library.ts', result.ts_content);
- * ```
- */
-export declare const library_generate: (input: LibraryGenerateInput) => LibraryGenerateResult;
-//# sourceMappingURL=library_generate.d.ts.map

package/dist/library_generate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"library_generate.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/library_generate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AACjC,OAAO,KAAK,EAAC,UAAU,EAAa,MAAM,iCAAiC,CAAC;AAC5E,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAGpD,OAAO,EAAC,KAAK,cAAc,EAAE,KAAK,mBAAmB,EAAC,MAAM,qBAAqB,CAAC;AAElF,OAAO,EAKN,KAAK,aAAa,EAClB,MAAM,uBAAuB,CAAC;AAI/B;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAClC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,EAC7C,GAAG,EAAE;IAAC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI,CAAA;CAAC,KAC3C,IAAI,CAAC;AAEV;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,EAAE,oBAiBzC,CAAC;AAEF,6CAA6C;AAC7C,MAAM,WAAW,oBAAoB;IACpC,0DAA0D;IAC1D,YAAY,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;IACpC,wCAAwC;IACxC,YAAY,EAAE,WAAW,CAAC;IAC1B,iDAAiD;IACjD,cAAc,EAAE,mBAAmB,CAAC;IACpC;;;OAGG;IACH,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC;IACrB,kEAAkE;IAClE,aAAa,CAAC,EAAE,oBAAoB,CAAC;IACrC,0DAA0D;IAC1D,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAED,6CAA6C;AAC7C,MAAM,WAAW,qBAAqB;IACrC,qCAAqC;IACrC,WAAW,EAAE,UAAU,CAAC;IACxB,gCAAgC;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,oBAAoB,KAAG,qBAuF9D,CAAC"}