svelte-docinfo 0.1.0

package/dist/typescript-extract-type-properties.js

@@ -0,0 +1,241 @@
+/**
+ * Property extraction for TypeScript type aliases.
+ *
+ * `extractTypeAliasProperties` walks the resolved type and emits members for
+ * named properties, index signatures, call signatures, and construct
+ * signatures. Handles object literals, intersections, mapped types
+ * (Partial, Pick, Readonly, etc.), type references, and function types.
+ * Called by `extractTypeInfo` in `typescript-extract-type.ts` for type
+ * aliases (interfaces use a different path that walks `node.members`
+ * directly).
+ *
+ * @see `typescript-extract-shared.ts` for shared helpers
+ * @see `typescript-extract-type.ts` for the dispatcher
+ *
+ * @module
+ */
+import ts from 'typescript';
+import {} from './diagnostics.js';
+import { parseComment, applyToDeclaration } from './tsdoc.js';
+import {} from './typescript-program.js';
+import { emitCallOrConstructSignature, filterIntersectionProperties, getNodeLocation, isExternalIntersectionBranch, populateCallableMember, resolveIntersectionTypeNode, } from './typescript-extract-shared.js';
+/**
+ * Check whether a resolved type has properties worth extracting for documentation.
+ *
+ * Returns `true` for object-like types (object literals, intersections, mapped types,
+ * type references, function types). Returns `false` for types where `getProperties()`
+ * would return prototype methods or ambiguous results (unions, primitives, tuples,
+ * generic type references like `Array<T>`).
+ */
+const hasExtractableProperties = (type) => {
+    // Intersections: checker merges properties from all branches
+    if (type.isIntersection())
+        return true;
+    // Unions: ambiguous property set (different branches have different shapes)
+    if (type.isUnion())
+        return false;
+    // Must be an object type
+    if (!(type.flags & ts.TypeFlags.Object))
+        return false;
+    const objFlags = type.objectFlags;
+    // Tuples give array prototype methods — not useful
+    if (objFlags & ts.ObjectFlags.Tuple)
+        return false;
+    // Generic type references (Array<T>, Promise<T>, Set<T>) give prototype methods.
+    // Mapped types can also have Reference when instantiated (Partial<T>, Pick<T,K>),
+    // so allow Reference when Mapped is also set.
+    if (objFlags & ts.ObjectFlags.Reference && !(objFlags & ts.ObjectFlags.Mapped))
+        return false;
+    return true;
+};
+/**
+ * Get the index type for a type, filtering out external branches in intersections.
+ *
+ * For non-intersection types, this delegates to `checker.getIndexTypeOfType`.
+ * For intersections, it walks each branch and returns the index type from the
+ * first local branch (skipping branches whose declarations are all in external
+ * files). Without this filtering, `getIndexTypeOfType` on the merged type would
+ * surface index signatures contributed only by external branches like
+ * `HTMLAttributes<HTMLDivElement>`, which is wrong for a library's own type.
+ *
+ * The "first local branch" simplification is conservative: multiple local
+ * branches contributing index signatures of the same kind would normally be
+ * intersected by the checker, but the merged result can also pull in external
+ * contributions through inheritance — so we prefer the simpler local path. This
+ * case is exceedingly rare in practice.
+ */
+const extractLocalIndexType = (nodeType, typeNode, checker, isExternalFile, indexKind) => {
+    if (!nodeType.isIntersection()) {
+        return checker.getIndexTypeOfType(nodeType, indexKind);
+    }
+    const intersectionNode = resolveIntersectionTypeNode(nodeType, typeNode);
+    if (!intersectionNode) {
+        // Cannot determine branches — fall back to merged type. Conservative:
+        // preserves prior behavior for the rare synthesized-intersection case.
+        return checker.getIndexTypeOfType(nodeType, indexKind);
+    }
+    for (const branch of intersectionNode.types) {
+        if (isExternalIntersectionBranch(branch, checker, isExternalFile))
+            continue;
+        const branchType = checker.getTypeAtLocation(branch);
+        const branchIndex = checker.getIndexTypeOfType(branchType, indexKind);
+        if (branchIndex)
+            return branchIndex;
+    }
+    return undefined;
+};
+/**
+ * Resolve, emit, and diagnose a local index signature for a type alias.
+ *
+ * Wraps `extractLocalIndexType` with the boilerplate shared by string and
+ * number kinds: push a `[key: string]` / `[key: number]` member when found,
+ * flip `partial: true` and add a `type_extraction_failed` diagnostic on
+ * checker errors. Pulled out of the call site to avoid copy-paste drift
+ * between the two kinds.
+ *
+ * @mutates declaration - appends a member when an index sig is present
+ * @mutates diagnostics - adds a `type_extraction_failed` diagnostic on checker error
+ */
+const emitLocalIndexSignature = (declaration, nodeType, node, checker, diagnostics, isExternalFile, kind) => {
+    const indexKind = kind === 'string' ? ts.IndexKind.String : ts.IndexKind.Number;
+    try {
+        const indexType = extractLocalIndexType(nodeType, node.type, checker, isExternalFile, indexKind);
+        if (indexType) {
+            (declaration.members ??= []).push({
+                name: `[key: ${kind}]`,
+                kind: 'variable',
+                typeSignature: checker.typeToString(indexType),
+            });
+        }
+    }
+    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 ${kind} index signature for type "${declaration.name ?? '<default export>'}": ${err instanceof Error ? err.message : String(err)}`,
+            severity: 'warning',
+            symbolName: declaration.name ?? '<default export>',
+        });
+    }
+};
+/**
+ * Detect whether a property symbol is readonly.
+ *
+ * Two-layer detection:
+ * 1. Check property declarations for `readonly` modifier (works for object literals,
+ *    intersections, type references)
+ * 2. For mapped types with a `readonly` token (e.g., `Readonly<T>`,
+ *    `{ readonly [K in ...]: ... }`), all properties are readonly regardless
+ *    of the original declaration
+ */
+const isReadonlyProperty = (prop, mappedReadonly) => {
+    const decls = prop.getDeclarations();
+    if (decls) {
+        for (const decl of decls) {
+            if (ts.canHaveModifiers(decl)) {
+                const mods = ts.getModifiers(decl);
+                if (mods?.some((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword))
+                    return true;
+            }
+        }
+    }
+    return mappedReadonly;
+};
+/**
+ * Extract properties from a type alias via the TypeScript checker API.
+ *
+ * Handles object literals, intersections, mapped types (Partial, Pick, Readonly, etc.),
+ * type references, and function types. Extracts:
+ * - Named properties (with readonly/optional detection, TSDoc from declarations)
+ * - Index signatures (string/number)
+ * - Call signatures (`(call)`)
+ * - Construct signatures (`(construct)`)
+ *
+ * @mutates declaration - adds members
+ */
+export const extractTypeAliasProperties = (node, nodeType, checker, declaration, diagnostics, isExternalFile) => {
+    if (!hasExtractableProperties(nodeType))
+        return;
+    // For intersection types, filter out properties from external sources (node_modules)
+    // and extract type names for the `intersects` field
+    const intersectionResult = filterIntersectionProperties(nodeType, node.type, checker, isExternalFile);
+    if (intersectionResult?.intersectionTypes.length) {
+        declaration.intersects = intersectionResult.intersectionTypes;
+    }
+    // Detect mapped-type-level readonly (e.g., Readonly<T>, { readonly [K in ...]: ... })
+    let mappedReadonly = false;
+    if (nodeType.flags & ts.TypeFlags.Object &&
+        nodeType.objectFlags & ts.ObjectFlags.Mapped) {
+        // ts.MappedType is not in the public API, but the `declaration` property
+        // exists at runtime on mapped types and holds the MappedTypeNode AST node
+        const mappedDecl = nodeType.declaration;
+        if (mappedDecl?.readonlyToken) {
+            mappedReadonly = true;
+        }
+    }
+    // Extract named properties (filtered for intersections, full for other types)
+    const properties = intersectionResult?.properties ?? nodeType.getProperties();
+    for (const prop of properties) {
+        // Skip internal TypeScript symbols
+        if (prop.getName().startsWith('__@'))
+            continue;
+        const optional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
+        const readonly = isReadonlyProperty(prop, mappedReadonly);
+        // Determine kind: function (has call signatures) vs variable (property)
+        let propType;
+        try {
+            propType = checker.getTypeOfSymbolAtLocation(prop, node);
+        }
+        catch {
+            continue;
+        }
+        const callSigs = propType.getCallSignatures();
+        const kind = callSigs.length > 0 ? 'function' : 'variable';
+        const member = {
+            name: prop.getName(),
+            kind,
+        };
+        if (optional)
+            member.optional = true;
+        // Modifiers
+        const modifiers = [];
+        if (readonly)
+            modifiers.push('readonly');
+        if (modifiers.length > 0)
+            member.modifiers = modifiers;
+        // Extract TSDoc from the property's declaration if available
+        const decls = prop.getDeclarations();
+        let propTsdoc = undefined;
+        if (decls && decls.length > 0) {
+            propTsdoc = parseComment(decls[0], decls[0].getSourceFile());
+            applyToDeclaration(member, propTsdoc);
+        }
+        // Type signature and function-specific fields
+        if (kind === 'function' && callSigs.length > 0) {
+            populateCallableMember(member, callSigs, checker, propTsdoc, decls?.[0] ?? node, prop.getName(), diagnostics);
+        }
+        else {
+            member.typeSignature = checker.typeToString(propType);
+            if (optional) {
+                // Strip trailing " | undefined" that the checker adds for optional props
+                member.typeSignature = checker.typeToString(checker.getNonNullableType(propType));
+            }
+        }
+        (declaration.members ??= []).push(member);
+    }
+    // Extract index signatures. For intersections, only emit signatures contributed
+    // by local branches — external branches like `HTMLAttributes<HTMLDivElement>`
+    // otherwise leak their string index signature onto the consuming type.
+    emitLocalIndexSignature(declaration, nodeType, node, checker, diagnostics, isExternalFile, 'string');
+    emitLocalIndexSignature(declaration, nodeType, node, checker, diagnostics, isExternalFile, 'number');
+    // Extract call and construct signatures. TSDoc resolves through the
+    // signature's own declaration — for type aliases, that's typically the
+    // inline call/construct signature node the user wrote.
+    const errorContext = { node, kindLabel: 'type' };
+    emitCallOrConstructSignature(() => nodeType.getCallSignatures(), 'call', (sig) => sig.getDeclaration(), node, declaration, checker, diagnostics, errorContext);
+    emitCallOrConstructSignature(() => nodeType.getConstructSignatures(), 'construct', (sig) => sig.getDeclaration(), node, declaration, checker, diagnostics, errorContext);
+};

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

@@ -0,0 +1,48 @@
+/**
+ * Per-declaration extractors for TypeScript type aliases, interfaces, and enums.
+ *
+ * `extractTypeInfo` handles type aliases and interfaces (including index/method/
+ * call/construct signatures and intersection filtering). `extractEnumInfo`
+ * handles regular and const enums. Both mutate a `DeclarationJsonBuild` with
+ * rich metadata derived from the TypeScript checker. Called by
+ * `analyzeDeclaration` in `typescript-exports.ts` once kind dispatch is
+ * settled.
+ *
+ * Type-alias property walking (named properties, index/call/construct
+ * signatures) lives in `typescript-extract-type-properties.ts` to keep this
+ * module focused on top-level dispatch.
+ *
+ * @see `typescript-extract-shared.ts` for shared helpers
+ * @see `typescript-extract-type-properties.ts` for type-alias property walking
+ *
+ * @module
+ */
+import ts from 'typescript';
+import type { DeclarationJsonBuild } from './declaration-build.js';
+import { type Diagnostic } from './diagnostics.js';
+import { type IsExternalFile } from './typescript-program.js';
+/**
+ * Extract type/interface information with rich property 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 typeSignature, genericParams, extends, intersects, members (and `partial: true` on extraction failure)
+ * @mutates diagnostics - adds `type_extraction_failed` / `signature_analysis_failed` diagnostics on checker errors
+ */
+export declare const extractTypeInfo: (node: ts.Node, checker: ts.TypeChecker, declaration: DeclarationJsonBuild, diagnostics: Array<Diagnostic>, isExternalFile: IsExternalFile) => void;
+/**
+ * Extract enum member information from an enum declaration.
+ *
+ * Iterates `node.members` to extract each enum member's name, initializer value,
+ * type, and JSDoc. Members are represented as `MemberJson` with kind `'variable'`.
+ *
+ * @internal Used by `analyzeDeclaration` — not part of the public barrel export.
+ *
+ * @mutates declaration - adds members and typeSignature
+ */
+export declare const extractEnumInfo: (node: ts.Node, checker: ts.TypeChecker, declaration: DeclarationJsonBuild, diagnostics: Array<Diagnostic>) => void;
+//# sourceMappingURL=typescript-extract-type.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-extract-type.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/typescript-extract-type.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,KAAK,EAAC,oBAAoB,EAAkB,MAAM,wBAAwB,CAAC;AAClF,OAAO,EAAC,KAAK,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAEjD,OAAO,EAAC,KAAK,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAU5D;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,GAC3B,MAAM,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,CAAC,WAAW,EACvB,aAAa,oBAAoB,EACjC,aAAa,KAAK,CAAC,UAAU,CAAC,EAC9B,gBAAgB,cAAc,KAC5B,IA4KF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,GAC3B,MAAM,EAAE,CAAC,IAAI,EACb,SAAS,EAAE,CAAC,WAAW,EACvB,aAAa,oBAAoB,EACjC,aAAa,KAAK,CAAC,UAAU,CAAC,KAC5B,IA6DF,CAAC"}

package/dist/typescript-extract-type.js

@@ -0,0 +1,238 @@
+/**
+ * Per-declaration extractors for TypeScript type aliases, interfaces, and enums.
+ *
+ * `extractTypeInfo` handles type aliases and interfaces (including index/method/
+ * call/construct signatures and intersection filtering). `extractEnumInfo`
+ * handles regular and const enums. Both mutate a `DeclarationJsonBuild` with
+ * rich metadata derived from the TypeScript checker. Called by
+ * `analyzeDeclaration` in `typescript-exports.ts` once kind dispatch is
+ * settled.
+ *
+ * Type-alias property walking (named properties, index/call/construct
+ * signatures) lives in `typescript-extract-type-properties.ts` to keep this
+ * module focused on top-level dispatch.
+ *
+ * @see `typescript-extract-shared.ts` for shared helpers
+ * @see `typescript-extract-type-properties.ts` for type-alias property walking
+ *
+ * @module
+ */
+import ts from 'typescript';
+import {} from './diagnostics.js';
+import { parseComment, applyToDeclaration } from './tsdoc.js';
+import {} from './typescript-program.js';
+import { emitCallOrConstructSignature, extractModifiers, getNodeLocation, parseGenericParam, populateCallableMember, } from './typescript-extract-shared.js';
+import { extractTypeAliasProperties } from './typescript-extract-type-properties.js';
+/**
+ * Extract type/interface information with rich property 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 typeSignature, genericParams, extends, intersects, members (and `partial: true` on extraction failure)
+ * @mutates diagnostics - adds `type_extraction_failed` / `signature_analysis_failed` diagnostics on checker errors
+ */
+export const extractTypeInfo = (node, checker, declaration, diagnostics, isExternalFile) => {
+    let nodeType;
+    try {
+        nodeType = checker.getTypeAtLocation(node);
+        declaration.typeSignature = checker.typeToString(nodeType);
+    }
+    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 "${declaration.name}": ${err instanceof Error ? err.message : String(err)}`,
+            severity: 'warning',
+            symbolName: declaration.name ?? '<default export>',
+        });
+    }
+    if (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node)) {
+        if (node.typeParameters?.length) {
+            declaration.genericParams = node.typeParameters.map(parseGenericParam);
+        }
+    }
+    if (ts.isTypeAliasDeclaration(node) && nodeType) {
+        extractTypeAliasProperties(node, nodeType, checker, declaration, diagnostics, isExternalFile);
+    }
+    if (ts.isInterfaceDeclaration(node)) {
+        if (node.heritageClauses) {
+            declaration.extends = node.heritageClauses
+                .filter((hc) => hc.token === ts.SyntaxKind.ExtendsKeyword)
+                .flatMap((hc) => hc.types.map((t) => t.getText()));
+        }
+        // Extract properties and method signatures with full metadata
+        const processedMethods = new Set();
+        for (const member of node.members) {
+            if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+                const propName = member.name.text;
+                const propDeclaration = {
+                    name: propName,
+                    kind: 'variable',
+                };
+                if (member.questionToken) {
+                    propDeclaration.optional = true;
+                }
+                // Extract modifiers
+                const modifierFlags = extractModifiers(ts.getModifiers(member));
+                if (modifierFlags.length > 0) {
+                    propDeclaration.modifiers = modifierFlags;
+                }
+                // Extract type
+                if (member.type) {
+                    propDeclaration.typeSignature = member.type.getText();
+                }
+                // Extract TSDoc (applies docComment, examples, deprecated, seeAlso, since)
+                const propTsdoc = parseComment(member, node.getSourceFile());
+                applyToDeclaration(propDeclaration, propTsdoc);
+                (declaration.members ??= []).push(propDeclaration);
+            }
+            else if (ts.isMethodSignature(member) && member.name) {
+                const methodName = ts.isIdentifier(member.name) ? member.name.text : member.name.getText();
+                if (!methodName || processedMethods.has(methodName))
+                    continue;
+                processedMethods.add(methodName);
+                const methodDeclaration = {
+                    name: methodName,
+                    kind: 'function',
+                };
+                if (member.questionToken) {
+                    methodDeclaration.optional = true;
+                }
+                // Extract modifiers
+                const modifierFlags = extractModifiers(ts.getModifiers(member));
+                if (modifierFlags.length > 0) {
+                    methodDeclaration.modifiers = modifierFlags;
+                }
+                // Extract generic type parameters
+                if (member.typeParameters?.length) {
+                    methodDeclaration.genericParams = member.typeParameters.map(parseGenericParam);
+                }
+                // Extract TSDoc
+                const methodTsdoc = parseComment(member, node.getSourceFile());
+                applyToDeclaration(methodDeclaration, methodTsdoc);
+                // Extract signatures via type checker
+                try {
+                    const memberSymbol = checker.getSymbolAtLocation(member.name);
+                    if (memberSymbol) {
+                        const memberType = checker.getTypeOfSymbolAtLocation(memberSymbol, member);
+                        populateCallableMember(methodDeclaration, memberType.getCallSignatures(), checker, methodTsdoc, member, methodName, diagnostics);
+                    }
+                }
+                catch (err) {
+                    methodDeclaration.partial = true;
+                    const loc = getNodeLocation(member);
+                    diagnostics.push({
+                        kind: 'signature_analysis_failed',
+                        file: loc.file,
+                        line: loc.line,
+                        column: loc.column,
+                        message: `Failed to analyze interface method "${methodName}": ${err instanceof Error ? err.message : String(err)}`,
+                        severity: 'warning',
+                        functionName: methodName,
+                    });
+                }
+                (declaration.members ??= []).push(methodDeclaration);
+            }
+            else if (ts.isIndexSignatureDeclaration(member)) {
+                const param = member.parameters[0];
+                if (param && ts.isIdentifier(param.name) && param.type) {
+                    const keyType = param.type.getText();
+                    const name = `[${param.name.text}: ${keyType}]`;
+                    const indexDeclaration = { name, kind: 'variable' };
+                    if (member.type) {
+                        indexDeclaration.typeSignature = member.type.getText();
+                    }
+                    const indexTsdoc = parseComment(member, node.getSourceFile());
+                    applyToDeclaration(indexDeclaration, indexTsdoc);
+                    (declaration.members ??= []).push(indexDeclaration);
+                }
+            }
+        }
+        // Extract call and construct signatures from interface type. TSDoc comes
+        // from inline signature declarations on this interface — inherited
+        // signatures resolve through `getCallSignatures()` but their docs are
+        // intentionally not surfaced here.
+        const interfaceType = nodeType ?? checker.getTypeAtLocation(node);
+        const errorContext = { node, kindLabel: 'interface' };
+        emitCallOrConstructSignature(() => interfaceType.getCallSignatures(), 'call', () => node.members.find(ts.isCallSignatureDeclaration), node, declaration, checker, diagnostics, errorContext);
+        emitCallOrConstructSignature(() => interfaceType.getConstructSignatures(), 'construct', () => node.members.find(ts.isConstructSignatureDeclaration), node, declaration, checker, diagnostics, errorContext);
+    }
+};
+/**
+ * Extract enum member information from an enum declaration.
+ *
+ * Iterates `node.members` to extract each enum member's name, initializer value,
+ * type, and JSDoc. Members are represented as `MemberJson` with kind `'variable'`.
+ *
+ * @internal Used by `analyzeDeclaration` — not part of the public barrel export.
+ *
+ * @mutates declaration - adds members and typeSignature
+ */
+export const extractEnumInfo = (node, checker, declaration, diagnostics) => {
+    // Extract type signature
+    try {
+        const nodeType = checker.getTypeAtLocation(node);
+        declaration.typeSignature = checker.typeToString(nodeType);
+    }
+    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 "${declaration.name}": ${err instanceof Error ? err.message : String(err)}`,
+            severity: 'warning',
+            symbolName: declaration.name ?? '<default export>',
+        });
+    }
+    if (!ts.isEnumDeclaration(node))
+        return;
+    for (const member of node.members) {
+        const memberName = ts.isIdentifier(member.name)
+            ? member.name.text
+            : ts.isStringLiteral(member.name)
+                ? member.name.text
+                : member.name.getText();
+        if (!memberName)
+            continue;
+        const memberDeclaration = {
+            name: memberName,
+            kind: 'variable',
+        };
+        // Extract TSDoc
+        const memberTsdoc = parseComment(member, node.getSourceFile());
+        applyToDeclaration(memberDeclaration, memberTsdoc);
+        // Extract type and value via the checker
+        try {
+            const memberSymbol = checker.getSymbolAtLocation(member.name);
+            if (memberSymbol) {
+                const memberType = checker.getTypeOfSymbolAtLocation(memberSymbol, member);
+                memberDeclaration.typeSignature = checker.typeToString(memberType);
+            }
+        }
+        catch (err) {
+            memberDeclaration.partial = true;
+            const loc = getNodeLocation(member);
+            diagnostics.push({
+                kind: 'type_extraction_failed',
+                file: loc.file,
+                line: loc.line,
+                column: loc.column,
+                message: `Failed to extract type for enum member "${memberName}" in "${declaration.name}": ${err instanceof Error ? err.message : String(err)}`,
+                severity: 'warning',
+                symbolName: memberName,
+            });
+        }
+        (declaration.members ??= []).push(memberDeclaration);
+    }
+};