svelte-docinfo 0.1.0

package/dist/typescript-extract-class.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Per-declaration extractor for TypeScript classes.
+ *
+ * `extractClassInfo` mutates a `DeclarationJsonBuild` with rich metadata
+ * derived from the class declaration: heritage clauses, generic parameters,
+ * properties, methods, constructors, and accessor pairs (getters/setters
+ * merged by name). Called by `analyzeDeclaration` in `typescript-exports.ts`
+ * once kind dispatch is settled.
+ *
+ * @see `typescript-extract-shared.ts` for shared helpers
+ *
+ * @module
+ */
+import ts from 'typescript';
+import type { DeclarationJsonBuild } from './declaration-build.js';
+import { type Diagnostic } from './diagnostics.js';
+/**
+ * Extract class information with rich member metadata.
+ *
+ * @internal Used by `analyzeDeclaration` — not part of the public barrel export.
+ *
+ * @param node - the declaration AST node
+ * @param checker - TypeScript type checker
+ * @param declaration - the declaration to populate
+ * @param diagnostics - diagnostics collector for non-fatal issues
+ * @mutates declaration - adds extends, implements, genericParams, members
+ */
+export declare const extractClassInfo: (node: ts.Node, checker: ts.TypeChecker, declaration: DeclarationJsonBuild, diagnostics: Array<Diagnostic>) => void;
+//# sourceMappingURL=typescript-extract-class.d.ts.map

package/dist/typescript-extract-class.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-extract-class.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/typescript-extract-class.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAC;AAG5B,OAAO,KAAK,EAAC,oBAAoB,EAAkB,MAAM,wBAAwB,CAAC;AAClF,OAAO,EAAC,KAAK,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAUjD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,GAC5B,MAAM,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,CAAC,WAAW,EACvB,aAAa,oBAAoB,EACjC,aAAa,KAAK,CAAC,UAAU,CAAC,KAC5B,IAwPF,CAAC"}

package/dist/typescript-extract-class.js

@@ -0,0 +1,251 @@
+/**
+ * Per-declaration extractor for TypeScript classes.
+ *
+ * `extractClassInfo` mutates a `DeclarationJsonBuild` with rich metadata
+ * derived from the class declaration: heritage clauses, generic parameters,
+ * properties, methods, constructors, and accessor pairs (getters/setters
+ * merged by name). Called by `analyzeDeclaration` in `typescript-exports.ts`
+ * once kind dispatch is settled.
+ *
+ * @see `typescript-extract-shared.ts` for shared helpers
+ *
+ * @module
+ */
+import ts from 'typescript';
+import {} from './diagnostics.js';
+import { parseComment, applyToDeclaration } from './tsdoc.js';
+import { detectReactivity, extractModifiers, getNodeLocation, parseGenericParam, populateCallableMember, } from './typescript-extract-shared.js';
+/**
+ * Extract class information with rich member metadata.
+ *
+ * @internal Used by `analyzeDeclaration` — not part of the public barrel export.
+ *
+ * @param node - the declaration AST node
+ * @param checker - TypeScript type checker
+ * @param declaration - the declaration to populate
+ * @param diagnostics - diagnostics collector for non-fatal issues
+ * @mutates declaration - adds extends, implements, genericParams, members
+ */
+export const extractClassInfo = (node, checker, declaration, diagnostics) => {
+    if (!ts.isClassDeclaration(node))
+        return;
+    if (node.heritageClauses) {
+        const extendsClause = node.heritageClauses.find((hc) => hc.token === ts.SyntaxKind.ExtendsKeyword);
+        if (extendsClause?.types[0]) {
+            declaration.extends = extendsClause.types[0].getText();
+        }
+        declaration.implements = node.heritageClauses
+            .filter((hc) => hc.token === ts.SyntaxKind.ImplementsKeyword)
+            .flatMap((hc) => hc.types.map((t) => t.getText()));
+    }
+    if (node.typeParameters?.length) {
+        declaration.genericParams = node.typeParameters.map(parseGenericParam);
+    }
+    // Extract members with full metadata
+    // Track processed constructors and methods to deduplicate overloads
+    let constructorProcessed = false;
+    const processedMethods = new Set();
+    for (const member of node.members) {
+        if (ts.isPropertyDeclaration(member) ||
+            ts.isMethodDeclaration(member) ||
+            ts.isConstructorDeclaration(member)) {
+            const isConstructor = ts.isConstructorDeclaration(member);
+            const memberName = isConstructor
+                ? 'constructor'
+                : ts.isIdentifier(member.name)
+                    ? member.name.text
+                    : member.name.getText();
+            if (!memberName)
+                continue;
+            // Skip private fields (those starting with #)
+            if (memberName.startsWith('#'))
+                continue;
+            // Skip private members - protected members are part of the extension API
+            const modifiers = ts.getModifiers(member);
+            if (modifiers) {
+                const isPrivate = modifiers.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword);
+                if (isPrivate)
+                    continue;
+            }
+            // Skip duplicate overload declarations — only process first occurrence
+            if (isConstructor) {
+                if (constructorProcessed)
+                    continue;
+                constructorProcessed = true;
+            }
+            else if (ts.isMethodDeclaration(member)) {
+                if (processedMethods.has(memberName))
+                    continue;
+                processedMethods.add(memberName);
+            }
+            const memberKind = isConstructor
+                ? 'constructor'
+                : ts.isMethodDeclaration(member)
+                    ? 'function'
+                    : 'variable';
+            const memberDeclaration = {
+                name: memberName,
+                kind: memberKind,
+            };
+            if (ts.isPropertyDeclaration(member) && member.questionToken) {
+                memberDeclaration.optional = true;
+            }
+            // Extract modifiers (reuse already-extracted modifiers array)
+            const modifierFlags = extractModifiers(modifiers);
+            if (modifierFlags.length > 0) {
+                memberDeclaration.modifiers = modifierFlags;
+            }
+            // Extract TSDoc (applies docComment, examples, deprecated, seeAlso, since, mutates)
+            const memberTsdoc = parseComment(member, node.getSourceFile());
+            applyToDeclaration(memberDeclaration, memberTsdoc);
+            // Extract type information and parameters for methods and constructors
+            try {
+                if (ts.isPropertyDeclaration(member)) {
+                    if (member.type) {
+                        memberDeclaration.typeSignature = member.type.getText();
+                    }
+                    else {
+                        // Fall back to inferred type for unannotated fields (e.g., `count = $state(0)`).
+                        const memberSymbol = checker.getSymbolAtLocation(member.name);
+                        if (memberSymbol) {
+                            const t = checker.getTypeOfSymbolAtLocation(memberSymbol, member);
+                            memberDeclaration.typeSignature = checker.typeToString(t);
+                        }
+                    }
+                }
+                else if (ts.isMethodDeclaration(member) || ts.isConstructorDeclaration(member)) {
+                    let signatures = [];
+                    if (isConstructor) {
+                        // Direct AST→signature path. Mirrors how methods (below) operate via
+                        // the member node, but constructors lack a `member.name` to detour
+                        // through. Works for both named and anonymous classes (the previous
+                        // `getSymbolAtLocation(node.name)` detour silently dropped signatures
+                        // for `export default class { ... }`).
+                        const ctorDecls = node.members.filter(ts.isConstructorDeclaration);
+                        // When overload signatures (no body) exist, only those count as
+                        // public signatures — the implementation is hidden. Mirrors what
+                        // `getConstructSignatures()` returns on the class type.
+                        const overloadDecls = ctorDecls.filter((c) => !c.body);
+                        const ctorsToUse = overloadDecls.length > 0 ? overloadDecls : ctorDecls;
+                        signatures = ctorsToUse
+                            .map((c) => checker.getSignatureFromDeclaration(c))
+                            .filter((s) => s !== undefined);
+                    }
+                    else {
+                        // For methods, get call signatures from the method symbol
+                        const memberSymbol = checker.getSymbolAtLocation(member.name);
+                        if (memberSymbol) {
+                            const memberType = checker.getTypeOfSymbolAtLocation(memberSymbol, member);
+                            signatures = memberType.getCallSignatures();
+                        }
+                    }
+                    populateCallableMember(memberDeclaration, signatures, checker, memberTsdoc, member, memberName, diagnostics, !isConstructor);
+                }
+            }
+            catch (err) {
+                memberDeclaration.partial = true;
+                const loc = getNodeLocation(member);
+                const className = node.name?.text ?? '<anonymous>';
+                diagnostics.push({
+                    kind: 'class_member_failed',
+                    file: loc.file,
+                    line: loc.line,
+                    column: loc.column,
+                    message: `Failed to analyze member "${memberName}" in class "${className}": ${err instanceof Error ? err.message : String(err)}`,
+                    severity: 'warning',
+                    className,
+                    memberName,
+                });
+            }
+            // Outside the try so reactivity is still captured if type extraction throws.
+            if (ts.isPropertyDeclaration(member)) {
+                const reactivity = detectReactivity(member.initializer);
+                if (reactivity)
+                    memberDeclaration.reactivity = reactivity;
+            }
+            (declaration.members ??= []).push(memberDeclaration);
+        }
+    }
+    // Extract accessors (getters/setters) - group by name to merge pairs
+    const accessors = new Map();
+    for (const member of node.members) {
+        if (ts.isGetAccessor(member) || ts.isSetAccessor(member)) {
+            const accessorName = ts.isIdentifier(member.name) ? member.name.text : member.name.getText();
+            if (!accessorName)
+                continue;
+            // Skip private accessors - protected are part of the extension API
+            const modifiers = ts.getModifiers(member);
+            if (modifiers) {
+                const isPrivate = modifiers.some((m) => m.kind === ts.SyntaxKind.PrivateKeyword);
+                if (isPrivate)
+                    continue;
+            }
+            const existing = accessors.get(accessorName) ?? { getter: null, setter: null };
+            if (ts.isGetAccessor(member)) {
+                existing.getter = member;
+            }
+            else {
+                existing.setter = member;
+            }
+            accessors.set(accessorName, existing);
+        }
+    }
+    // Create declarations for accessor pairs
+    for (const [accessorName, { getter, setter }] of accessors) {
+        const accessorDeclaration = {
+            name: accessorName,
+            kind: 'variable',
+        };
+        // Build modifiers: getter/setter indicators + other modifiers (static, etc.)
+        const accessorModifiers = [];
+        if (getter)
+            accessorModifiers.push('getter');
+        if (setter)
+            accessorModifiers.push('setter');
+        // Extract other modifiers from getter (or setter if no getter)
+        const primaryAccessor = getter ?? setter;
+        const otherModifiers = extractModifiers(ts.getModifiers(primaryAccessor));
+        accessorModifiers.push(...otherModifiers);
+        if (accessorModifiers.length > 0) {
+            accessorDeclaration.modifiers = accessorModifiers;
+        }
+        // Extract TSDoc - prefer getter's, fall back to setter's
+        const getterTsdoc = getter ? parseComment(getter, node.getSourceFile()) : undefined;
+        const setterTsdoc = setter ? parseComment(setter, node.getSourceFile()) : undefined;
+        const accessorTsdoc = getterTsdoc ?? setterTsdoc;
+        applyToDeclaration(accessorDeclaration, accessorTsdoc);
+        // Extract type signature from getter's return type
+        try {
+            if (getter) {
+                const getterSymbol = checker.getSymbolAtLocation(getter.name);
+                if (getterSymbol) {
+                    const getterType = checker.getTypeOfSymbolAtLocation(getterSymbol, getter);
+                    accessorDeclaration.typeSignature = checker.typeToString(getterType);
+                }
+            }
+            else if (setter?.parameters.length) {
+                // Fall back to setter's parameter type if no getter
+                const param = setter.parameters[0];
+                if (param.type) {
+                    accessorDeclaration.typeSignature = param.type.getText();
+                }
+            }
+        }
+        catch (err) {
+            accessorDeclaration.partial = true;
+            const loc = getNodeLocation(primaryAccessor);
+            const className = node.name?.text ?? '<anonymous>';
+            diagnostics.push({
+                kind: 'class_member_failed',
+                file: loc.file,
+                line: loc.line,
+                column: loc.column,
+                message: `Failed to analyze accessor "${accessorName}" in class "${className}": ${err instanceof Error ? err.message : String(err)}`,
+                severity: 'warning',
+                className,
+                memberName: accessorName,
+            });
+        }
+        (declaration.members ??= []).push(accessorDeclaration);
+    }
+};

package/dist/typescript-extract-function.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Per-declaration extractors for TypeScript functions and variables.
+ *
+ * Both `extractFunctionInfo` and `extractVariableInfo` mutate a
+ * `DeclarationJsonBuild` with rich metadata derived from the TypeScript
+ * checker. Called by `analyzeDeclaration` in `typescript-exports.ts` once
+ * kind dispatch is settled.
+ *
+ * @see `typescript-extract-shared.ts` for shared helpers (signatures,
+ *   overloads, generics, reactivity)
+ *
+ * @module
+ */
+import ts from 'typescript';
+import type { DeclarationJsonBuild } from './declaration-build.js';
+import { type Diagnostic } from './diagnostics.js';
+import type { TsdocParsedComment } from './tsdoc.js';
+/**
+ * Extract function/method information including parameters
+ * with descriptions and default values.
+ *
+ * @internal Used by `analyzeDeclaration` — not part of the public barrel export.
+ *
+ * @param node - the declaration AST node
+ * @param symbol - the TypeScript symbol
+ * @param checker - TypeScript type checker
+ * @param declaration - the declaration to populate
+ * @param tsdoc - parsed TSDoc comment (if available)
+ * @param diagnostics - diagnostics collector for non-fatal issues
+ * @mutates declaration - adds typeSignature, returnType, returnDescription, parameters, genericParams, overloads (and `partial: true` on signature failure)
+ * @mutates diagnostics - adds `signature_analysis_failed` diagnostic on checker error
+ */
+export declare const extractFunctionInfo: (node: ts.Node, symbol: ts.Symbol, checker: ts.TypeChecker, declaration: DeclarationJsonBuild, tsdoc: TsdocParsedComment | undefined, diagnostics: Array<Diagnostic>) => void;
+/**
+ * Extract variable information.
+ *
+ * @internal Used by `analyzeDeclaration` — not part of the public barrel export.
+ *
+ * @param node - the declaration AST node
+ * @param symbol - the TypeScript symbol
+ * @param checker - TypeScript type checker
+ * @param declaration - the declaration to populate
+ * @param diagnostics - diagnostics collector for non-fatal issues
+ * @mutates declaration - adds typeSignature, reactivity (when initialized with a Svelte rune)
+ */
+export declare const extractVariableInfo: (node: ts.Node, symbol: ts.Symbol, checker: ts.TypeChecker, declaration: DeclarationJsonBuild, diagnostics: Array<Diagnostic>) => void;
+//# sourceMappingURL=typescript-extract-function.d.ts.map

package/dist/typescript-extract-function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-extract-function.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/typescript-extract-function.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAC,KAAK,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,YAAY,CAAC;AAQnD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,GAC/B,MAAM,EAAE,CAAC,IAAI,EACb,QAAQ,EAAE,CAAC,MAAM,EACjB,SAAS,EAAE,CAAC,WAAW,EACvB,aAAa,oBAAoB,EACjC,OAAO,kBAAkB,GAAG,SAAS,EACrC,aAAa,KAAK,CAAC,UAAU,CAAC,KAC5B,IAuCF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,GAC/B,MAAM,EAAE,CAAC,IAAI,EACb,QAAQ,EAAE,CAAC,MAAM,EACjB,SAAS,EAAE,CAAC,WAAW,EACvB,aAAa,oBAAoB,EACjC,aAAa,KAAK,CAAC,UAAU,CAAC,KAC5B,IAuBF,CAAC"}

package/dist/typescript-extract-function.js

@@ -0,0 +1,108 @@
+/**
+ * Per-declaration extractors for TypeScript functions and variables.
+ *
+ * Both `extractFunctionInfo` and `extractVariableInfo` mutate a
+ * `DeclarationJsonBuild` with rich metadata derived from the TypeScript
+ * checker. Called by `analyzeDeclaration` in `typescript-exports.ts` once
+ * kind dispatch is settled.
+ *
+ * @see `typescript-extract-shared.ts` for shared helpers (signatures,
+ *   overloads, generics, reactivity)
+ *
+ * @module
+ */
+import ts from 'typescript';
+import {} from './diagnostics.js';
+import { detectReactivity, getNodeLocation, parseGenericParam, populateCallableMember, } from './typescript-extract-shared.js';
+/**
+ * Extract function/method information including parameters
+ * with descriptions and default values.
+ *
+ * @internal Used by `analyzeDeclaration` — not part of the public barrel export.
+ *
+ * @param node - the declaration AST node
+ * @param symbol - the TypeScript symbol
+ * @param checker - TypeScript type checker
+ * @param declaration - the declaration to populate
+ * @param tsdoc - parsed TSDoc comment (if available)
+ * @param diagnostics - diagnostics collector for non-fatal issues
+ * @mutates declaration - adds typeSignature, returnType, returnDescription, parameters, genericParams, overloads (and `partial: true` on signature failure)
+ * @mutates diagnostics - adds `signature_analysis_failed` diagnostic on checker error
+ */
+export const extractFunctionInfo = (node, symbol, checker, declaration, tsdoc, diagnostics) => {
+    try {
+        const type = checker.getTypeOfSymbolAtLocation(symbol, node);
+        const signatures = type.getCallSignatures();
+        populateCallableMember(declaration, signatures, checker, tsdoc, node, symbol.name, diagnostics);
+    }
+    catch (err) {
+        declaration.partial = true;
+        const loc = getNodeLocation(node);
+        diagnostics.push({
+            kind: 'signature_analysis_failed',
+            file: loc.file,
+            line: loc.line,
+            column: loc.column,
+            message: `Failed to analyze signature for "${symbol.name}": ${err instanceof Error ? err.message : String(err)}`,
+            severity: 'warning',
+            functionName: symbol.name,
+        });
+    }
+    // Extract generic type parameters
+    let typeParameters;
+    if (ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+        typeParameters = node.typeParameters;
+    }
+    else if (ts.isVariableDeclaration(node)) {
+        if (node.type && ts.isFunctionTypeNode(node.type)) {
+            // `export const fn: <T>(x: T) => T = (x) => x` — generics on the type annotation.
+            // Annotation wins over initializer when both carry generics: it's the public type.
+            typeParameters = node.type.typeParameters;
+        }
+        else if (node.initializer &&
+            (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+            // `export const foo = <T>(x: T) => x` — generics live on the initializer, not the variable.
+            typeParameters = node.initializer.typeParameters;
+        }
+    }
+    if (typeParameters?.length) {
+        declaration.genericParams = typeParameters.map(parseGenericParam);
+    }
+};
+/**
+ * Extract variable information.
+ *
+ * @internal Used by `analyzeDeclaration` — not part of the public barrel export.
+ *
+ * @param node - the declaration AST node
+ * @param symbol - the TypeScript symbol
+ * @param checker - TypeScript type checker
+ * @param declaration - the declaration to populate
+ * @param diagnostics - diagnostics collector for non-fatal issues
+ * @mutates declaration - adds typeSignature, reactivity (when initialized with a Svelte rune)
+ */
+export const extractVariableInfo = (node, symbol, checker, declaration, diagnostics) => {
+    try {
+        const type = checker.getTypeOfSymbolAtLocation(symbol, node);
+        declaration.typeSignature = checker.typeToString(type);
+    }
+    catch (err) {
+        declaration.partial = true;
+        const loc = getNodeLocation(node);
+        diagnostics.push({
+            kind: 'type_extraction_failed',
+            file: loc.file,
+            line: loc.line,
+            column: loc.column,
+            message: `Failed to extract type for variable "${symbol.name}": ${err instanceof Error ? err.message : String(err)}`,
+            severity: 'warning',
+            symbolName: symbol.name,
+        });
+    }
+    // Outside the try so reactivity is still captured if type extraction throws.
+    if (ts.isVariableDeclaration(node)) {
+        const reactivity = detectReactivity(node.initializer);
+        if (reactivity)
+            declaration.reactivity = reactivity;
+    }
+};

package/dist/typescript-extract-shared.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Shared utilities for the per-declaration extractors in `typescript-extract-*.ts`.
+ *
+ * Holds helpers used across function, type, and class extraction: signature
+ * parameter extraction, overload detection, generic parsing, modifier
+ * extraction, location reporting, intersection-property filtering, and runes
+ * detection.
+ *
+ * @see `typescript-extract-function.ts`, `typescript-extract-type.ts`,
+ *   `typescript-extract-class.ts` for the per-declaration extractors that
+ *   build on these helpers
+ *
+ * @module
+ */
+import ts from 'typescript';
+import type { GenericParamJson, DeclarationKind, DeclarationModifier, ParameterJson, Reactivity } from './types.js';
+import type { DeclarationJsonBuild, MemberJsonBuild } from './declaration-build.js';
+import { type Diagnostic } from './diagnostics.js';
+import { type TsdocParsedComment } from './tsdoc.js';
+import { type IsExternalFile } from './typescript-program.js';
+/**
+ * Infer declaration kind from symbol and node.
+ *
+ * Maps TypeScript constructs to `DeclarationKind`:
+ * - Classes → `'class'`
+ * - Functions (declarations, expressions, arrows) → `'function'`
+ * - Interfaces → `'interface'`
+ * - Type aliases → `'type'`
+ * - Enums (regular and const) → `'enum'`
+ * - Variables → `'variable'` (unless function-valued → `'function'`)
+ *
+ * Note: namespace re-exports (`export * as ns from './x'`) have no inline
+ * declaration form in TypeScript and are caught upstream in `analyzeExports`
+ * via `classifyNamespaceReExport`. They never reach this function. A direct
+ * call here on a `ValueModule` symbol would fall through to `'variable'` and
+ * leak `typeof import("/abs/path")` into the output — keep the namespace
+ * dispatch in `analyzeExports`.
+ */
+export declare const inferDeclarationKind: (symbol: ts.Symbol, node: ts.Node) => DeclarationKind;
+/**
+ * Extract parameters from a TypeScript signature with TSDoc descriptions and default values.
+ *
+ * Shared helper for extracting parameter information from both standalone functions
+ * and class methods/constructors.
+ *
+ * @param sig - the TypeScript signature to extract parameters from
+ * @param checker - TypeScript type checker for type resolution
+ * @param tsdocParams - record of parameter names to TSDoc descriptions (from `TsdocParsedComment.params`)
+ * @returns array of `ParameterJson` objects
+ */
+export declare const extractSignatureParameters: (sig: ts.Signature, checker: ts.TypeChecker, tsdocParams: Record<string, string> | undefined) => Array<ParameterJson>;
+/**
+ * Populate the callable fields of a declaration or member from its call/construct
+ * signatures: `typeSignature`, `parameters`, `overloads`, and (unless
+ * `includeReturn` is false) `returnType` / `returnDescription`.
+ *
+ * The shared core of every named-callable extractor — standalone functions,
+ * interface methods, class methods/constructors, and type-alias function
+ * properties. Callers differ in how they obtain `signatures` (symbol type,
+ * constructor declarations, property call signatures) and in their own
+ * try/catch + diagnostic kind, so those stay at the callsite; this captures
+ * only the identical projection from a resolved signature list onto the build
+ * target. No-op when `signatures` is empty.
+ *
+ * @param target - declaration or member build object (mutated)
+ * @param signatures - public call/construct signatures (`signatures[0]` is primary)
+ * @param tsdoc - parsed TSDoc for the target (supplies `@param`/`@returns`)
+ * @param paramValidationNode - node `validateParamKeys` reports `unknown_param` against
+ * @param name - target name, for diagnostic messages
+ * @param includeReturn - set `false` for constructors (no return type/description)
+ * @mutates target - sets typeSignature, parameters, overloads, returnType, returnDescription
+ * @mutates diagnostics - via `validateParamKeys` / `extractOverloads`
+ */
+export declare const populateCallableMember: (target: DeclarationJsonBuild | MemberJsonBuild, signatures: ReadonlyArray<ts.Signature>, checker: ts.TypeChecker, tsdoc: TsdocParsedComment | undefined, paramValidationNode: ts.Node, name: string, diagnostics: Array<Diagnostic>, includeReturn?: boolean) => void;
+/**
+ * Determine whether an intersection branch refers to a type whose declarations
+ * all live in external files (e.g., `HTMLAttributes<HTMLDivElement>` from svelte's
+ * d.ts). Inline object-literal branches and unrecognized node shapes return false
+ * (treated as local).
+ */
+export declare const isExternalIntersectionBranch: (branchNode: ts.TypeNode, checker: ts.TypeChecker, isExternalFile: IsExternalFile) => boolean;
+/**
+ * Resolve the `IntersectionTypeNode` for a type node, walking through type
+ * alias indirection. Returns `undefined` when the underlying type is an
+ * intersection but no AST node is recoverable (rare — synthesized intersections).
+ */
+export declare const resolveIntersectionTypeNode: (type: ts.Type, typeNode: ts.Node) => ts.IntersectionTypeNode | undefined;
+/**
+ * Filter intersection type properties to exclude those from external sources,
+ * and extract type names for branches whose properties are all external.
+ *
+ * Returns `null` for non-intersection types (caller should use unfiltered properties).
+ * For intersection types, returns filtered properties and external type names.
+ *
+ * Per-property filtering works through utility types (Partial, Pick, Readonly)
+ * because TypeScript preserves original declaration sources on mapped type properties.
+ */
+export declare const filterIntersectionProperties: (type: ts.Type, typeNode: ts.Node, checker: ts.TypeChecker, isExternalFile: IsExternalFile) => {
+    properties: Array<ts.Symbol>;
+    intersectionTypes: Array<string>;
+} | null;
+/**
+ * Detect a Svelte 5 reactivity rune from a variable or property initializer.
+ *
+ * Inspects the AST since runes erase to their inner type after type-checking.
+ * Returns `undefined` for any non-rune expression. See the `Reactivity` enum
+ * in `types.ts` for the rationale on running this on every file regardless of
+ * extension.
+ */
+export declare const detectReactivity: (initializer: ts.Expression | undefined) => Reactivity | undefined;
+/**
+ * Extract line and column from a TypeScript node.
+ * Returns 1-based line and column numbers.
+ */
+export declare const getNodeLocation: (node: ts.Node) => {
+    file: string;
+    line: number;
+    column: number;
+};
+/**
+ * Parse a TypeScript generic type parameter declaration into structured info.
+ *
+ * @param param - the TypeScript type parameter declaration node
+ * @returns structured `GenericParamJson` with name, constraint, and default type
+ */
+export declare const parseGenericParam: (param: ts.TypeParameterDeclaration) => GenericParamJson;
+/**
+ * Extract modifier keywords from a node's modifiers.
+ *
+ * Returns an array of modifier strings like `['public', 'readonly', 'static']`.
+ */
+export declare const extractModifiers: (modifiers: ReadonlyArray<ts.ModifierLike> | undefined) => Array<DeclarationModifier>;
+/**
+ * Append a `(call)` or `(construct)` signature member to a declaration.
+ *
+ * Captures the extraction logic shared by interface processing
+ * (`extractTypeInfo`) and type-alias property processing
+ * (`extractTypeAliasProperties`): type signature, parameters, generics,
+ * overloads, and TSDoc. The TSDoc source node is supplied by the caller —
+ * interfaces look it up in `node.members` (skipping TSDoc when no inline
+ * signature is declared, even if one is inherited), type aliases use
+ * `sig.getDeclaration()`.
+ *
+ * @param getSignatures - thunk to retrieve `getCallSignatures()` /
+ *   `getConstructSignatures()`; called inside the try so checker errors are
+ *   captured as diagnostics
+ * @param signatureKind - `'call'` (member kind: function, includes returnType)
+ *   or `'construct'` (member kind: constructor, no returnType)
+ * @param resolveTsdocNode - callback returning the AST node to parse TSDoc
+ *   from, or `undefined` to skip TSDoc resolution
+ * @param paramValidationFallbackNode - location used by `validateParamKeys`
+ *   when `resolveTsdocNode` returns `undefined`
+ * @param declaration - parent declaration (mutated; appended to `members`)
+ * @param errorContext.node - parent node used to locate diagnostics
+ * @param errorContext.kindLabel - `'interface'` or `'type'`, included in the
+ *   diagnostic message
+ *
+ * @mutates declaration - appends a member when signatures are present;
+ *   sets `partial: true` on extraction failure
+ * @mutates diagnostics - adds `signature_analysis_failed` on checker error
+ */
+export declare const emitCallOrConstructSignature: (getSignatures: () => ReadonlyArray<ts.Signature>, signatureKind: "call" | "construct", resolveTsdocNode: (sig: ts.Signature) => ts.Node | undefined, paramValidationFallbackNode: ts.Node, declaration: DeclarationJsonBuild, checker: ts.TypeChecker, diagnostics: Array<Diagnostic>, errorContext: {
+    node: ts.Node;
+    kindLabel: string;
+}) => void;
+//# sourceMappingURL=typescript-extract-shared.d.ts.map

package/dist/typescript-extract-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-extract-shared.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/typescript-extract-shared.ts"],"names":[],"mappings":"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"}