@pikku/inspector 0.6.3 → 0.7.0

package/dist/utils.js

@@ -1,248 +1,670 @@
 import * as ts from 'typescript';
-export const extractTypeKeys = (type) => {
-    return type.getProperties().map((symbol) => symbol.getName());
-};
-export const nullifyTypes = (type) => {
-    if (type === 'void' ||
-        type === 'undefined' ||
-        type === 'unknown' ||
-        type === 'any') {
-        return null;
-    }
-    return type;
-};
-const isValidVariableName = (name) => {
-    const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-    return regex.test(name);
-};
-export const getNamesAndTypes = (checker, typesMap, direction, funcName, type) => {
-    const result = {
-        names: new Set(),
-        types: [],
-    };
-    const { names, types } = resolveUnionTypes(checker, type);
-    const firstName = names[0];
-    if (names.length > 1 || (firstName && !isValidVariableName(firstName))) {
-        const aliasType = names.join(' | ');
-        const aliasName = `${funcName.charAt(0).toUpperCase()}${funcName.slice(1)}${direction}`;
-        result.names = new Set([aliasName]);
-        result.types = types;
-        const references = types
-            .map((t) => resolveTypeImports(t, typesMap, true))
-            .flat();
-        typesMap.addCustomType(aliasName, aliasType, references);
+/**
+ * Generate a deterministic "anonymous" name for any expression node,
+ * but if it's an Identifier pointing to a function, resolve it back
+ * to the function's declaration (so you get the true source location).
+ */
+export function makeDeterministicAnonName(start, checker) {
+    let node = start;
+    let target = start;
+    // Handle the case where we're starting with an identifier directly
+    if (ts.isIdentifier(node)) {
+        const sym = checker.getSymbolAtLocation(node);
+        if (sym) {
+            let resolvedSym = sym;
+            if (resolvedSym.flags & ts.SymbolFlags.Alias) {
+                resolvedSym = checker.getAliasedSymbol(resolvedSym) ?? resolvedSym;
+            }
+            const decls = resolvedSym.declarations ?? [];
+            if (decls.length > 0) {
+                // Start with the declaration, not the reference
+                const decl = decls[0];
+                // If it's a variable declaration with a function initializer, use the function directly
+                if (ts.isVariableDeclaration(decl) &&
+                    decl.initializer &&
+                    (ts.isFunctionExpression(decl.initializer) ||
+                        ts.isArrowFunction(decl.initializer))) {
+                    target = decl.initializer;
+                    // Return early - we found the function directly
+                    const sf = target.getSourceFile();
+                    const file = sf.fileName.replace(/[^A-Za-z0-9_]/g, '_');
+                    const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
+                    return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
+                }
+                // Otherwise continue resolution with the declaration
+                node = decl;
+                target = decl;
+            }
+        }
     }
-    else {
-        const uniqueNames = names
-            .map((name, i) => {
-            const type = types[i];
-            if (!type) {
-                throw new Error('TODO: Expected a type here to match name');
-            }
-            if (isPrimitiveType(type)) {
-                return name;
-            }
-            return resolveTypeImports(type, typesMap, false);
-        })
-            .flat();
-        result.names = new Set(uniqueNames);
-        result.types = types;
-    }
-    return {
-        names: Array.from(result.names),
-        types: result.types,
-    };
-};
-export const isPrimitiveType = (type) => {
-    const primitiveFlags = ts.TypeFlags.Number |
-        ts.TypeFlags.String |
-        ts.TypeFlags.Boolean |
-        ts.TypeFlags.BigInt |
-        ts.TypeFlags.ESSymbol |
-        ts.TypeFlags.Void |
-        ts.TypeFlags.Undefined |
-        ts.TypeFlags.Null |
-        ts.TypeFlags.Any |
-        ts.TypeFlags.Unknown;
-    return (type.flags & primitiveFlags) !== 0;
-};
-export const resolveUnionTypes = (checker, type) => {
-    const types = [];
-    const names = [];
-    // Check if it's a union type AND not part of an intersection
-    if (type.isUnion() && !(type.flags & ts.TypeFlags.Intersection)) {
-        for (const t of type.types) {
-            const name = nullifyTypes(checker.typeToString(t));
-            if (name) {
-                types.push(t);
-                names.push(name);
+    // In an object literal property value, first try to resolve the identifier
+    if (ts.isPropertyAssignment(node.parent) &&
+        node === node.parent.initializer &&
+        ts.isIdentifier(node)) {
+        const sym = checker.getSymbolAtLocation(node);
+        if (sym) {
+            // Process the symbol to find the real declaration
+            let resolvedSym = sym;
+            if (resolvedSym.flags & ts.SymbolFlags.Alias) {
+                resolvedSym = checker.getAliasedSymbol(resolvedSym) ?? resolvedSym;
+            }
+            const decls = resolvedSym.declarations ?? [];
+            if (decls.length > 0) {
+                // Found a declaration - use it as our new target
+                const decl = decls[0];
+                if (!decl) {
+                    throw new Error('No declaration found');
+                }
+                // If it's a variable declaration with an initializer function, use that
+                if (ts.isVariableDeclaration(decl) && decl.initializer) {
+                    if (ts.isFunctionExpression(decl.initializer) ||
+                        ts.isArrowFunction(decl.initializer)) {
+                        target = decl.initializer;
+                        // Return early - we found the function directly
+                        const sf = target.getSourceFile();
+                        const file = sf.fileName.replace(/[^A-Za-z0-9_]/g, '_');
+                        const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
+                        return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
+                    }
+                }
+                else if (ts.isFunctionDeclaration(decl)) {
+                    // Already a function declaration
+                    target = decl;
+                    // Return early
+                    const sf = target.getSourceFile();
+                    const file = sf.fileName.replace(/[^A-Za-z0-9_]/g, '_');
+                    const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
+                    return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
+                }
+                // If we didn't return early, continue with this declaration
+                node = decl;
+                target = decl;
             }
         }
     }
-    else {
-        const name = nullifyTypes(checker.typeToString(type));
-        if (name) {
-            types.push(type);
-            names.push(name);
+    const seen = new Set();
+    for (let depth = 0; depth < 10; depth++) {
+        if (!ts.isIdentifier(node) || seen.has(node))
+            break;
+        seen.add(node);
+        let sym = checker.getSymbolAtLocation(node);
+        if (!sym)
+            break;
+        if (sym.flags & ts.SymbolFlags.Alias) {
+            sym = checker.getAliasedSymbol(sym) ?? sym;
         }
+        const allDecls = sym.declarations ?? [];
+        // prefer real .ts/.tsx implementation files
+        const implDecls = allDecls.filter((d) => !d.getSourceFile().isDeclarationFile);
+        const decls = implDecls.length ? implDecls : allDecls;
+        let didResolve = false;
+        for (const decl of decls) {
+            // 1) direct function foo() {} or function-expression
+            if (ts.isFunctionDeclaration(decl) ||
+                ts.isFunctionExpression(decl) ||
+                ts.isArrowFunction(decl)) {
+                target = decl;
+                didResolve = true;
+                break;
+            }
+            // 2) const foo = () => {} or foo = function() {}
+            if (ts.isVariableDeclaration(decl) && decl.initializer) {
+                const init = decl.initializer;
+                if (ts.isFunctionExpression(init) || ts.isArrowFunction(init)) {
+                    target = init;
+                    didResolve = true;
+                    break;
+                }
+                // 2b) const foo = bar;  (follow the next identifier)
+                if (ts.isIdentifier(init)) {
+                    node = init;
+                    target = init;
+                    didResolve = true;
+                    break;
+                }
+            }
+            // 3) Handle shorthand property assignments: { foo } (equivalent to { foo: foo })
+            if (ts.isShorthandPropertyAssignment(decl)) {
+                // Get the symbol for the shorthand property
+                const shorthandSym = checker.getShorthandAssignmentValueSymbol(decl);
+                if (shorthandSym &&
+                    shorthandSym.declarations &&
+                    shorthandSym.declarations.length > 0) {
+                    // Use the first declaration as our new target
+                    const shorthandDecl = shorthandSym.declarations[0];
+                    target = shorthandDecl;
+                    if (!shorthandDecl) {
+                        throw new Error('No shorthand declaration found');
+                    }
+                    // Check the type of declaration and extract the appropriate identifier to continue resolving
+                    if (ts.isVariableDeclaration(shorthandDecl) &&
+                        ts.isIdentifier(shorthandDecl.name)) {
+                        node = shorthandDecl.name;
+                        didResolve = true;
+                        break;
+                    }
+                    else if (ts.isFunctionDeclaration(shorthandDecl) &&
+                        shorthandDecl.name &&
+                        ts.isIdentifier(shorthandDecl.name)) {
+                        node = shorthandDecl.name;
+                        didResolve = true;
+                        break;
+                    }
+                    else if (ts.isParameter(shorthandDecl) &&
+                        ts.isIdentifier(shorthandDecl.name)) {
+                        node = shorthandDecl.name;
+                        didResolve = true;
+                        break;
+                    }
+                    else if (ts.isPropertyDeclaration(shorthandDecl) &&
+                        ts.isIdentifier(shorthandDecl.name)) {
+                        node = shorthandDecl.name;
+                        didResolve = true;
+                        break;
+                    }
+                    else if (ts.isMethodDeclaration(shorthandDecl) &&
+                        ts.isIdentifier(shorthandDecl.name)) {
+                        node = shorthandDecl.name;
+                        didResolve = true;
+                        break;
+                    }
+                }
+            }
+            // 4) Handle method declarations in classes/objects
+            if (ts.isMethodDeclaration(decl)) {
+                target = decl;
+                didResolve = true;
+                break;
+            }
+            // you can add more cases here if your setup uses imports, etc.
+        }
+        if (!didResolve)
+            break;
     }
-    return { types, names };
-};
-export const resolveTypeImports = (type, resolvedTypes, isCustom) => {
-    const types = [];
-    const visitType = (currentType) => {
-        const symbol = currentType.aliasSymbol || currentType.getSymbol();
-        if (symbol) {
-            const declarations = symbol.getDeclarations();
-            const declaration = declarations?.[0];
-            if (declaration) {
-                const sourceFile = declaration.getSourceFile();
-                const path = sourceFile.fileName;
-                // Skip built-in utility types or TypeScript lib types
-                if (!path.includes('node_modules/typescript') &&
-                    symbol.getName() !== '__type' &&
-                    !isPrimitiveType(currentType)) {
-                    const originalName = symbol.getName();
-                    // Check if the type is already in the map
-                    let uniqueName = resolvedTypes.exists(originalName, path);
-                    if (!uniqueName) {
-                        if (isCustom) {
-                            uniqueName = resolvedTypes.addUniqueType(originalName, path);
-                        }
-                        else {
-                            resolvedTypes.addType(originalName, path);
-                            uniqueName = originalName;
+    const sf = target.getSourceFile();
+    const file = sf.fileName.replace(/[^A-Za-z0-9_]/g, '_');
+    const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
+    return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
+}
+/**
+ * Updated function to extract and prioritize function names correctly
+ * This function follows the priority:
+ * 1. Object with a name property
+ * 2. Exported name
+ * 3. Fallback to deterministic name
+ */
+export function extractFunctionName(callExpr, checker) {
+    const parent = callExpr.parent;
+    // Initialize the result
+    const result = {
+        pikkuFuncName: '', // Will be populated later
+        name: '', // This will hold our "best" name based on priority
+        exportedName: null,
+        functionName: null,
+        propertyName: null,
+    };
+    // Special case for addHTTPRoute: if this is an identifier within an object literal,
+    // it might be coming from the HTTP route handling flow
+    if (ts.isIdentifier(callExpr) &&
+        callExpr.parent &&
+        ts.isPropertyAssignment(callExpr.parent)) {
+        // Try to handle the special case for HTTP route functions
+        const sym = checker.getSymbolAtLocation(callExpr);
+        if (sym) {
+            let resolvedSym = sym;
+            if (resolvedSym.flags & ts.SymbolFlags.Alias) {
+                resolvedSym = checker.getAliasedSymbol(resolvedSym) ?? resolvedSym;
+            }
+            const decls = resolvedSym.declarations ?? [];
+            if (decls.length > 0) {
+                const decl = decls[0];
+                // Check if the declaration is a variable that uses pikkuSessionlessFunc
+                if (ts.isVariableDeclaration(decl) && decl.initializer) {
+                    if (ts.isCallExpression(decl.initializer) &&
+                        ts.isIdentifier(decl.initializer.expression) &&
+                        decl.initializer.expression.text.startsWith('pikku')) {
+                        const args = decl.initializer.arguments;
+                        const firstArg = args[0];
+                        if (firstArg &&
+                            (ts.isArrowFunction(firstArg) ||
+                                ts.isFunctionExpression(firstArg))) {
+                            // Use the function directly for position calculation
+                            result.pikkuFuncName = makeDeterministicAnonName(firstArg, checker);
+                            // Continue with name extraction
+                            if (ts.isIdentifier(parent.name)) {
+                                result.propertyName = parent.name.text;
+                            }
+                            // Check if the variable is exported
+                            if (ts.isVariableDeclaration(decl) &&
+                                isNamedExport(decl) &&
+                                ts.isIdentifier(decl.name)) {
+                                result.exportedName = decl.name.text;
+                            }
+                            else if (ts.isIdentifier(decl.name)) {
+                                // If not exported, still capture the variable name
+                                result.functionName = decl.name.text;
+                            }
+                            // Apply name priority logic
+                            populateNameByPriority(result);
+                            return result;
                         }
                     }
-                    types.push(uniqueName);
                 }
             }
         }
-        if (isCustom) {
-            // Handle nested utility types like Partial, Pick, etc.
-            if (currentType.aliasTypeArguments) {
-                currentType.aliasTypeArguments.forEach(visitType);
-            }
-            // Handle intersections and unions
-            if (currentType.isUnionOrIntersection()) {
-                currentType.types.forEach(visitType);
+    }
+    // First, figure out what function we're really dealing with
+    let mainFunc = callExpr;
+    let originalCallExpr = callExpr; // Keep track of the original call expression for name extraction
+    // For direct pikku function calls where callExpr is the call expression itself
+    if (ts.isCallExpression(callExpr)) {
+        const { expression, arguments: args } = callExpr;
+        // Check if this is a pikku function call (pikkuFunc, pikkuSessionlessFunc, etc)
+        if (ts.isIdentifier(expression) && expression.text.startsWith('pikku')) {
+            // Check for object with 'name' property in first argument
+            const firstArg = args[0];
+            if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
+                for (const prop of firstArg.properties) {
+                    if (ts.isPropertyAssignment(prop) &&
+                        ts.isIdentifier(prop.name) &&
+                        prop.name.text === 'name' &&
+                        ts.isStringLiteral(prop.initializer)) {
+                        // Priority 1: Object with name property
+                        result.functionName = prop.initializer.text;
+                        break;
+                    }
+                }
             }
-            // Handle object types with type arguments
-            if (currentType.flags & ts.TypeFlags.Object &&
-                currentType.objectFlags & ts.ObjectFlags.Reference) {
-                const typeRef = currentType;
-                typeRef.typeArguments?.forEach(visitType);
+            // Special handling for pikkuSessionlessFunc pattern - use the arrow function directly
+            if (expression.text.startsWith('pikku')) {
+                if (args.length > 0) {
+                    const firstArg = args[0];
+                    if (ts.isArrowFunction(firstArg) ||
+                        ts.isFunctionExpression(firstArg)) {
+                        mainFunc = firstArg; // Use the arrow function directly instead of the call expression
+                    }
+                }
             }
         }
-    };
-    visitType(type);
-    return types;
-};
-export const getPropertyAssignment = (obj, name) => {
-    const property = obj.properties.find((p) => (ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)) &&
-        ts.isIdentifier(p.name) &&
-        p.name.text === name);
-    if (!property) {
-        console.error(`Missing property '${name}' in object`);
-        return null;
-    }
-    return property;
-};
-export const getTypeArgumentsOfType = (checker, type) => {
-    if (type.isUnionOrIntersection()) {
-        const types = [];
-        for (const subType of type.types) {
-            const subTypeArgs = getTypeArgumentsOfType(checker, subType);
-            if (subTypeArgs) {
-                types.push(...subTypeArgs);
+        // Handle object initializer with a func property (for both patterns)
+        if (args.length > 0) {
+            const firstArg = args[0];
+            if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
+                // Look for func property in the object
+                for (const prop of firstArg.properties) {
+                    if (ts.isPropertyAssignment(prop) &&
+                        ts.isIdentifier(prop.name) &&
+                        prop.name.text === 'func') {
+                        if (ts.isIdentifier(prop.initializer)) {
+                            // func: someFunction - resolve the function
+                            const funcSym = checker.getSymbolAtLocation(prop.initializer);
+                            if (funcSym) {
+                                let resolvedFuncSym = funcSym;
+                                if (resolvedFuncSym.flags & ts.SymbolFlags.Alias) {
+                                    resolvedFuncSym =
+                                        checker.getAliasedSymbol(resolvedFuncSym) ?? resolvedFuncSym;
+                                }
+                                const funcDecls = resolvedFuncSym.declarations ?? [];
+                                if (funcDecls.length > 0) {
+                                    const funcDecl = funcDecls[0];
+                                    // Check if it's a pikkuSessionlessFunc
+                                    if (ts.isVariableDeclaration(funcDecl) &&
+                                        funcDecl.initializer) {
+                                        if (ts.isCallExpression(funcDecl.initializer) &&
+                                            ts.isIdentifier(funcDecl.initializer.expression) &&
+                                            funcDecl.initializer.expression.text.startsWith('pikku')) {
+                                            const funcArgs = funcDecl.initializer.arguments;
+                                            const firstArg = funcArgs[0];
+                                            if (firstArg &&
+                                                (ts.isArrowFunction(firstArg) ||
+                                                    ts.isFunctionExpression(firstArg))) {
+                                                mainFunc = firstArg;
+                                                // Check if the variable is exported
+                                                if (isNamedExport(funcDecl) &&
+                                                    ts.isIdentifier(funcDecl.name)) {
+                                                    result.exportedName = funcDecl.name.text;
+                                                }
+                                                else if (ts.isIdentifier(funcDecl.name)) {
+                                                    // If not exported, still capture the variable name
+                                                    result.functionName = funcDecl.name.text;
+                                                }
+                                                break;
+                                            }
+                                        }
+                                        else if (ts.isFunctionExpression(funcDecl.initializer) ||
+                                            ts.isArrowFunction(funcDecl.initializer)) {
+                                            mainFunc = funcDecl.initializer;
+                                            // Check if the variable is exported
+                                            if (isNamedExport(funcDecl) &&
+                                                ts.isIdentifier(funcDecl.name)) {
+                                                result.exportedName = funcDecl.name.text;
+                                            }
+                                            else if (ts.isIdentifier(funcDecl.name)) {
+                                                // If not exported, still capture the variable name
+                                                result.functionName = funcDecl.name.text;
+                                            }
+                                            break;
+                                        }
+                                    }
+                                    else if (ts.isFunctionDeclaration(funcDecl)) {
+                                        mainFunc = funcDecl;
+                                        // Check if the function is exported
+                                        if (funcDecl.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
+                                            funcDecl.name &&
+                                            ts.isIdentifier(funcDecl.name)) {
+                                            result.exportedName = funcDecl.name.text;
+                                        }
+                                        else if (funcDecl.name &&
+                                            ts.isIdentifier(funcDecl.name)) {
+                                            // If not exported, still capture the function name
+                                            result.functionName = funcDecl.name.text;
+                                        }
+                                        break;
+                                    }
+                                }
+                            }
+                            else {
+                                // If we can't resolve the symbol, use the identifier itself
+                                mainFunc = prop.initializer;
+                            }
+                            break;
+                        }
+                        else if (ts.isFunctionExpression(prop.initializer) ||
+                            ts.isArrowFunction(prop.initializer)) {
+                            // func: () => {} or func: function() {} - use directly
+                            mainFunc = prop.initializer;
+                            break;
+                        }
+                    }
+                    else if (ts.isShorthandPropertyAssignment(prop) &&
+                        ts.isIdentifier(prop.name) &&
+                        prop.name.text === 'func') {
+                        // Handle func shorthand property
+                        const shorthandSym = checker.getShorthandAssignmentValueSymbol(prop);
+                        if (shorthandSym &&
+                            shorthandSym.declarations &&
+                            shorthandSym.declarations.length > 0) {
+                            const shorthandDecl = shorthandSym.declarations[0];
+                            if (!shorthandDecl) {
+                                throw new Error('No shorthand declaration found');
+                            }
+                            if (ts.isVariableDeclaration(shorthandDecl) &&
+                                shorthandDecl.initializer) {
+                                if (ts.isCallExpression(shorthandDecl.initializer) &&
+                                    ts.isIdentifier(shorthandDecl.initializer.expression) &&
+                                    shorthandDecl.initializer.expression.text.startsWith('pikku')) {
+                                    const args = shorthandDecl.initializer.arguments;
+                                    const firstArg = args[0];
+                                    if (firstArg &&
+                                        (ts.isArrowFunction(firstArg) ||
+                                            ts.isFunctionExpression(firstArg))) {
+                                        mainFunc = firstArg;
+                                        // Check if the variable is exported
+                                        if (isNamedExport(shorthandDecl) &&
+                                            ts.isIdentifier(shorthandDecl.name)) {
+                                            result.exportedName = shorthandDecl.name.text;
+                                        }
+                                        else if (ts.isIdentifier(shorthandDecl.name)) {
+                                            // If not exported, still capture the variable name
+                                            result.functionName = shorthandDecl.name.text;
+                                        }
+                                        break;
+                                    }
+                                }
+                                else if (ts.isFunctionExpression(shorthandDecl.initializer) ||
+                                    ts.isArrowFunction(shorthandDecl.initializer)) {
+                                    mainFunc = shorthandDecl.initializer;
+                                    // Check if the variable is exported
+                                    if (isNamedExport(shorthandDecl) &&
+                                        ts.isIdentifier(shorthandDecl.name)) {
+                                        result.exportedName = shorthandDecl.name.text;
+                                    }
+                                    else if (ts.isIdentifier(shorthandDecl.name)) {
+                                        // If not exported, still capture the variable name
+                                        result.functionName = shorthandDecl.name.text;
+                                    }
+                                    break;
+                                }
+                            }
+                            else if (ts.isFunctionDeclaration(shorthandDecl)) {
+                                mainFunc = shorthandDecl;
+                                // Check if the function is exported
+                                if (shorthandDecl.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
+                                    shorthandDecl.name &&
+                                    ts.isIdentifier(shorthandDecl.name)) {
+                                    result.exportedName = shorthandDecl.name.text;
+                                }
+                                else if (shorthandDecl.name &&
+                                    ts.isIdentifier(shorthandDecl.name)) {
+                                    // If not exported, still capture the function name
+                                    result.functionName = shorthandDecl.name.text;
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
             }
         }
-        return types.length > 0 ? types : null;
-    }
-    // If the type is a TypeReference with typeArguments, return them
-    if (type.flags & ts.TypeFlags.Object &&
-        type.objectFlags & ts.ObjectFlags.Reference) {
-        const typeRef = type;
-        if (typeRef.typeArguments && typeRef.typeArguments.length > 0) {
-            return typeRef.typeArguments;
-        }
     }
-    // If the type is an alias with aliasTypeArguments, return them
-    if (type.aliasTypeArguments && type.aliasTypeArguments.length > 0) {
-        return type.aliasTypeArguments;
-    }
-    return null;
-};
-export const getFunctionTypes = (checker, obj, { typesMap, funcName, subFunctionName = funcName, inputIndex, outputIndex, }) => {
-    const result = {
-        inputTypes: [],
-        inputs: null,
-        outputTypes: [],
-        outputs: null,
-    };
-    const property = getPropertyAssignment(obj, subFunctionName);
-    if (!property) {
-        return result;
-    }
-    let type;
-    // Handle shorthand property assignment
-    if (ts.isShorthandPropertyAssignment(property)) {
-        const symbol = checker.getShorthandAssignmentValueSymbol(property);
-        if (symbol) {
-            type = checker.getTypeOfSymbolAtLocation(symbol, property);
-            if (funcName === 'func') {
-                funcName = symbol.name;
+    // Handle direct identifier case
+    else if (ts.isIdentifier(callExpr)) {
+        const sym = checker.getSymbolAtLocation(callExpr);
+        if (sym) {
+            let resolvedSym = sym;
+            if (resolvedSym.flags & ts.SymbolFlags.Alias) {
+                resolvedSym = checker.getAliasedSymbol(resolvedSym) ?? resolvedSym;
+            }
+            const decls = resolvedSym.declarations ?? [];
+            if (decls.length > 0) {
+                const decl = decls[0];
+                if (!decl) {
+                    throw new Error('No declaration found');
+                }
+                if (ts.isVariableDeclaration(decl) && decl.initializer) {
+                    if (ts.isCallExpression(decl.initializer) &&
+                        ts.isIdentifier(decl.initializer.expression) &&
+                        decl.initializer.expression.text.startsWith('pikku')) {
+                        // Check for object with 'name' property in first argument
+                        const firstArg = decl.initializer.arguments[0];
+                        if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
+                            for (const prop of firstArg.properties) {
+                                if (ts.isPropertyAssignment(prop) &&
+                                    ts.isIdentifier(prop.name) &&
+                                    prop.name.text === 'name' &&
+                                    ts.isStringLiteral(prop.initializer)) {
+                                    // Priority 1: Object with name property
+                                    result.functionName = prop.initializer.text;
+                                    break;
+                                }
+                            }
+                        }
+                        if (decl.initializer.expression.text.startsWith('pikku')) {
+                            if (firstArg &&
+                                (ts.isArrowFunction(firstArg) ||
+                                    ts.isFunctionExpression(firstArg))) {
+                                mainFunc = firstArg;
+                            }
+                        }
+                        // Check if the variable is exported
+                        if (isNamedExport(decl) && ts.isIdentifier(decl.name)) {
+                            result.exportedName = decl.name.text;
+                        }
+                        else if (ts.isIdentifier(decl.name)) {
+                            // If not explicitly set by name property above, set functionName
+                            if (!result.functionName) {
+                                result.functionName = decl.name.text;
+                            }
+                        }
+                    }
+                    else if (ts.isFunctionExpression(decl.initializer) ||
+                        ts.isArrowFunction(decl.initializer)) {
+                        mainFunc = decl.initializer;
+                        // Check if the variable is exported
+                        if (isNamedExport(decl) && ts.isIdentifier(decl.name)) {
+                            result.exportedName = decl.name.text;
+                        }
+                        else if (ts.isIdentifier(decl.name)) {
+                            result.functionName = decl.name.text;
+                        }
+                    }
+                }
+                else if (ts.isFunctionDeclaration(decl)) {
+                    mainFunc = decl;
+                    // Check if the function is exported
+                    if (decl.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
+                        decl.name &&
+                        ts.isIdentifier(decl.name)) {
+                        result.exportedName = decl.name.text;
+                    }
+                    else if (decl.name && ts.isIdentifier(decl.name)) {
+                        result.functionName = decl.name.text;
+                    }
+                }
             }
         }
     }
-    // Handle regular property assignment
-    else if (ts.isPropertyAssignment(property)) {
-        if (ts.isObjectLiteralExpression(property.initializer)) {
-            return getFunctionTypes(checker, property.initializer, {
-                typesMap,
-                funcName,
-                subFunctionName: 'func',
-                inputIndex,
-                outputIndex,
-            });
+    // Now generate the deterministic function name based on the resolved function
+    result.pikkuFuncName = makeDeterministicAnonName(mainFunc, checker);
+    // Continue with regular name extraction for remaining cases
+    // 1) const foo = pikkuFunc(...)
+    if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+        if (isNamedExport(parent)) {
+            result.exportedName = parent.name.text;
         }
-        if (property.initializer) {
-            type = checker.getTypeAtLocation(property.initializer);
-            if (funcName === 'func') {
-                funcName = property.initializer.getText();
-            }
+        else {
+            // Still capture the variable name even if not exported
+            result.functionName = parent.name.text;
         }
     }
-    if (!type) {
-        console.error(`Unable to resolve type for property '${funcName}'`);
-        return result;
+    // 2) { foo: pikkuFunc(...) }
+    else if (ts.isPropertyAssignment(parent) && ts.isIdentifier(parent.name)) {
+        result.propertyName = parent.name.text;
+    }
+    // 2b) Handle shorthand property { foo } - which is equivalent to { foo: foo }
+    else if (ts.isShorthandPropertyAssignment(parent) &&
+        ts.isIdentifier(parent.name)) {
+        result.propertyName = parent.name.text;
     }
-    // Access type arguments from TypeReference
-    const typeArguments = getTypeArgumentsOfType(checker, type);
-    if (!typeArguments || typeArguments.length === 0) {
-        // This is the case for inline functions. In this case we would want to
-        // get the types from the second argument of the function...
-        console.error(`\x1b[31m• No generic type arguments found for ${funcName}. Support for inline functions is not yet implemented.\x1b[0m`);
-        return result;
+    // 3) Handle any remaining cases for pikkuFunc({ name: '…', func: … })
+    else if (ts.isCallExpression(originalCallExpr)) {
+        const firstArg = originalCallExpr.arguments[0];
+        if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
+            for (const prop of firstArg.properties) {
+                if (ts.isPropertyAssignment(prop) &&
+                    ts.isIdentifier(prop.name) &&
+                    prop.name.text === 'name' &&
+                    ts.isStringLiteral(prop.initializer) &&
+                    !result.functionName // Only set if not already set
+                ) {
+                    result.functionName = prop.initializer.text;
+                    break;
+                }
+            }
+        }
     }
-    if (inputIndex !== undefined && inputIndex < typeArguments.length) {
-        const { names, types } = getNamesAndTypes(checker, typesMap, 'Input', funcName, typeArguments[inputIndex]);
-        result.inputs = names;
-        result.inputTypes = types;
+    // Apply name priority logic
+    populateNameByPriority(result);
+    return result;
+}
+/**
+ * Helper function to populate the 'name' field based on priority
+ */
+function populateNameByPriority(result) {
+    // Priority 1: If we have a functionName (from name property or variable name), use that
+    if (result.functionName) {
+        result.name = result.functionName;
     }
-    else {
-        console.log(`No input defined for ${funcName}`);
+    // Priority 2: If we have an exported name, use that
+    else if (result.exportedName) {
+        result.name = result.exportedName;
     }
-    if (outputIndex !== undefined && outputIndex < typeArguments.length) {
-        const { names, types } = getNamesAndTypes(checker, typesMap, 'Output', funcName, typeArguments[outputIndex]);
-        result.outputs = names;
-        result.outputTypes = types;
+    // Priority 3: If we have a property name, use that
+    else if (result.propertyName) {
+        result.name = result.propertyName;
     }
+    // Fallback: Use the deterministic name, but we could shorten it in the future
     else {
-        console.info(`No output defined for ${funcName}`);
+        // For now, just use the full pikkuFuncName
+        result.name = result.pikkuFuncName;
+        // Alternative: extract just the filename and line/column from pikkuFuncName
+        // const nameParts = result.pikkuFuncName.split('_');
+        // if (nameParts.length >= 3) {
+        //   // Extract just filename + line/column info
+        //   result.name = `${nameParts[1]}_${nameParts[2]}`;
+        // }
     }
-    return result;
+}
+/**
+ * Helper function to check if a variable declaration is a named export
+ */
+function isNamedExport(declaration) {
+    let parent = declaration.parent;
+    if (!parent)
+        return false;
+    // Check if it's part of a variable declaration list
+    if (ts.isVariableDeclarationList(parent)) {
+        parent = parent.parent;
+        if (!parent)
+            return false;
+        // Check if it's in an export declaration
+        if (ts.isVariableStatement(parent)) {
+            return (parent.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ??
+                false);
+        }
+    }
+    return false;
+}
+// Until here
+export const extractTypeKeys = (type) => {
+    return type.getProperties().map((symbol) => symbol.getName());
 };
+export function getPropertyAssignmentInitializer(obj, propName, followShorthand = false, checker) {
+    for (const prop of obj.properties) {
+        // ①  foo: () => {}
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === propName) {
+            return prop.initializer;
+        }
+        // ②  foo() { … }
+        if (ts.isMethodDeclaration(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === propName) {
+            return prop.name; // the method node *is* the function
+        }
+        // ③  { foo }  (shorthand)
+        if (followShorthand &&
+            ts.isShorthandPropertyAssignment(prop) &&
+            prop.name.text === propName) {
+            if (!checker)
+                return prop.name; // best effort without a checker
+            let sym = checker.getSymbolAtLocation(prop.name);
+            if (sym && sym.flags & ts.SymbolFlags.Alias) {
+                sym = checker.getAliasedSymbol(sym);
+            }
+            const decl = sym?.declarations?.[0];
+            // const foo = () => {}
+            if (decl &&
+                ts.isVariableDeclaration(decl) &&
+                decl.initializer &&
+                (ts.isArrowFunction(decl.initializer) ||
+                    ts.isFunctionExpression(decl.initializer))) {
+                return decl.initializer;
+            }
+            // function foo() {}
+            if (decl &&
+                (ts.isFunctionDeclaration(decl) ||
+                    ts.isArrowFunction(decl) ||
+                    ts.isFunctionExpression(decl))) {
+                return decl;
+            }
+            // fallback – just give back the identifier
+            return prop.name;
+        }
+    }
+    return undefined;
+}
 export const matchesFilters = (filters, params, meta) => {
     if (Object.keys(filters).length === 0 || filters.tags?.length === 0) {
         return true;