@pikku/inspector 0.6.4 → 0.7.1

package/src/utils.ts

@@ -1,356 +1,848 @@
 import * as ts from 'typescript'
-import { TypesMap } from './types-map.js'
 import { InspectorFilters } from './types.js'
 
-type FunctionTypes = {
-  type: string | null
-  inputTypes: ts.Type[]
-  inputs: null | string[]
-  outputTypes: ts.Type[]
-  outputs: null | string[]
+type ExtractedFunctionName = {
+  pikkuFuncName: string
+  name: string
+  exportedName: string | null
+  functionName: string | null
+  propertyName: string | null
 }
 
-export const extractTypeKeys = (type: ts.Type): string[] => {
-  return type.getProperties().map((symbol) => symbol.getName())
-}
+/**
+ * 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: ts.Node,
+  checker: ts.TypeChecker
+): string {
+  let node: ts.Node = start
+  let target: ts.Node = 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
+      }
 
-export const nullifyTypes = (type: string | null) => {
+      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!
+      }
+    }
+  }
+
+  // In an object literal property value, first try to resolve the identifier
   if (
-    type === 'void' ||
-    type === 'undefined' ||
-    type === 'unknown' ||
-    type === 'any'
+    ts.isPropertyAssignment(node.parent) &&
+    node === node.parent.initializer &&
+    ts.isIdentifier(node)
   ) {
-    return null
-  }
-  return type
-}
+    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 isValidVariableName = (name: string) => {
-  const regex = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/
-  return regex.test(name)
-}
+      const decls = resolvedSym.declarations ?? []
+      if (decls.length > 0) {
+        // Found a declaration - use it as our new target
+        const decl = decls[0]
 
-export const getNamesAndTypes = (
-  checker: ts.TypeChecker,
-  typesMap: TypesMap,
-  direction: 'Input' | 'Output',
-  funcName: string,
-  type: ts.Type
-) => {
-  const result: {
-    names: Set<string>
-    types: ts.Type[]
-  } = {
-    names: new Set(),
-    types: [],
+        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
+      }
+    }
   }
 
-  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)
-  } else {
-    const uniqueNames = names
-      .map((name, i) => {
-        const type = types[i]
-        if (!type) {
-          throw new Error('TODO: Expected a type here to match name')
+  const seen = new Set<ts.Node>()
+  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
         }
-        if (isPrimitiveType(type)) {
-          return name
+        // 2b) const foo = bar;  (follow the next identifier)
+        if (ts.isIdentifier(init)) {
+          node = init
+          target = init
+          didResolve = true
+          break
         }
-        return resolveTypeImports(type, typesMap, false)
-      })
-      .flat()
-    result.names = new Set(uniqueNames)
-    result.types = types
-  }
+      }
 
-  return {
-    names: Array.from(result.names),
-    types: result.types,
-  }
-}
+      // 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
 
-export const isPrimitiveType = (type: ts.Type): boolean => {
-  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
-}
+          if (!shorthandDecl) {
+            throw new Error('No shorthand declaration found')
+          }
 
-export const resolveUnionTypes = (
-  checker: ts.TypeChecker,
-  type: ts.Type
-): { types: ts.Type[]; names: string[] } => {
-  const types: ts.Type[] = []
-  const names: string[] = []
-
-  // 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)
+          // 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.
     }
-  } else {
-    const name = nullifyTypes(checker.typeToString(type))
-    if (name) {
-      types.push(type)
-      names.push(name)
-    }
+
+    if (!didResolve) break
   }
 
-  return { types, names }
+  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}`
 }
 
-export const resolveTypeImports = (
-  type: ts.Type,
-  resolvedTypes: TypesMap,
-  isCustom: boolean
-): string[] => {
-  const types: string[] = []
-
-  const visitType = (currentType: ts.Type) => {
-    const symbol = currentType.aliasSymbol || currentType.getSymbol()
+/**
+ * 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: ts.Node,
+  checker: ts.TypeChecker
+): ExtractedFunctionName {
+  const parent: any = callExpr.parent
+
+  // Initialize the result
+  const result: ExtractedFunctionName = {
+    pikkuFuncName: '', // Will be populated later
+    name: '', // This will hold our "best" name based on priority
+    exportedName: null,
+    functionName: null,
+    propertyName: null,
+  }
 
-    if (symbol) {
-      const declarations = symbol.getDeclarations()
-      const declaration = declarations?.[0]
-      if (declaration) {
-        const sourceFile = declaration.getSourceFile()
-        const path = sourceFile.fileName
+  // 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
+      }
 
-        // 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 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)
+  // 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 intersections and unions
-      if (currentType.isUnionOrIntersection()) {
-        currentType.types.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
+          }
+        }
       }
+    }
 
-      // Handle object types with type arguments
-      if (
-        currentType.flags & ts.TypeFlags.Object &&
-        (currentType as ts.ObjectType).objectFlags & ts.ObjectFlags.Reference
-      ) {
-        const typeRef = currentType as ts.TypeReference
-        typeRef.typeArguments?.forEach(visitType)
+    // 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
+              }
+            }
+          }
+        }
       }
     }
   }
+  // 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
+      }
 
-  visitType(type)
-  return types
-}
+      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
+                }
+              }
+            }
 
-export const getPropertyAssignment = (
-  obj: ts.ObjectLiteralExpression,
-  name: string
-) => {
-  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
-}
+            if (decl.initializer.expression.text.startsWith('pikku')) {
+              if (
+                firstArg &&
+                (ts.isArrowFunction(firstArg) ||
+                  ts.isFunctionExpression(firstArg))
+              ) {
+                mainFunc = firstArg
+              }
+            }
 
-export const getTypeArgumentsOfType = (
-  checker: ts.TypeChecker,
-  type: ts.Type
-): readonly ts.Type[] | null => {
-  if (type.isUnionOrIntersection()) {
-    const types: ts.Type[] = []
-    for (const subType of type.types) {
-      const subTypeArgs = getTypeArgumentsOfType(checker, subType)
-      if (subTypeArgs) {
-        types.push(...subTypeArgs)
+            // 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
+          }
+        }
       }
     }
-    return types.length > 0 ? types : null
   }
 
-  // If the type is a TypeReference with typeArguments, return them
-  if (
-    type.flags & ts.TypeFlags.Object &&
-    (type as ts.ObjectType).objectFlags & ts.ObjectFlags.Reference
-  ) {
-    const typeRef = type as ts.TypeReference
-    if (typeRef.typeArguments && typeRef.typeArguments.length > 0) {
-      return typeRef.typeArguments
+  // 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
+    } else {
+      // Still capture the variable name even if not exported
+      result.functionName = parent.name.text
     }
   }
-
-  // If the type is an alias with aliasTypeArguments, return them
-  if (type.aliasTypeArguments && type.aliasTypeArguments.length > 0) {
-    return type.aliasTypeArguments as ts.Type[]
+  // 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
+  }
+  // 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
+        }
+      }
+    }
   }
 
-  return null
+  // Apply name priority logic
+  populateNameByPriority(result)
+  return result
 }
 
-export const getFunctionTypes = (
-  checker: ts.TypeChecker,
-  obj: ts.ObjectLiteralExpression,
-  {
-    typesMap,
-    funcName,
-    subFunctionName = funcName,
-    inputIndex,
-    outputIndex,
-  }: {
-    typesMap: TypesMap
-    subFunctionName?: string
-    funcName: string
-    inputIndex: number
-    outputIndex: number
+/**
+ * Helper function to populate the 'name' field based on priority
+ */
+function populateNameByPriority(result: ExtractedFunctionName): void {
+  // Priority 1: If we have a functionName (from name property or variable name), use that
+  if (result.functionName) {
+    result.name = result.functionName
   }
-): FunctionTypes => {
-  const result: FunctionTypes = {
-    inputTypes: [],
-    inputs: null,
-    outputTypes: [],
-    outputs: null,
-    type: null,
+  // Priority 2: If we have an exported name, use that
+  else if (result.exportedName) {
+    result.name = result.exportedName
   }
-
-  const property = getPropertyAssignment(obj, subFunctionName)
-  if (!property) {
-    return result
+  // 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 {
+    // 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]}`;
+    // }
+  }
+}
 
-  let type: ts.Type | undefined
-
-  // 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
-      }
+/**
+ * Helper function to check if a variable declaration is a named export
+ */
+function isNamedExport(declaration: ts.VariableDeclaration): boolean {
+  let parent: any = 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
+      )
     }
   }
-  // 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,
-      })
-    }
 
-    if (property.initializer) {
-      type = checker.getTypeAtLocation(property.initializer)
-      if (funcName === 'func') {
-        funcName = property.initializer.getText()
-      }
+  return false
+}
+
+// Until here
+export const extractTypeKeys = (type: ts.Type): string[] => {
+  return type.getProperties().map((symbol) => symbol.getName())
+}
+
+export function getPropertyAssignmentInitializer(
+  obj: ts.ObjectLiteralExpression,
+  propName: string,
+  followShorthand = false,
+  checker?: ts.TypeChecker
+): ts.Expression | undefined {
+  for (const prop of obj.properties) {
+    // ①  foo: () => {}
+    if (
+      ts.isPropertyAssignment(prop) &&
+      ts.isIdentifier(prop.name) &&
+      prop.name.text === propName
+    ) {
+      return prop.initializer
     }
-  }
 
-  if (!type) {
-    console.error(`Unable to resolve type for property '${funcName}'`)
-    return result
-  }
+    // ②  foo() { … }
+    if (
+      ts.isMethodDeclaration(prop) &&
+      ts.isIdentifier(prop.name) &&
+      prop.name.text === propName
+    ) {
+      return prop.name // the method node *is* the function
+    }
 
-  result.type = type.aliasSymbol?.getEscapedName() || null
+    // ③  { 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)
+      }
 
-  // Access type arguments from TypeReference
-  const typeArguments = getTypeArgumentsOfType(checker, type)
+      const decl = sym?.declarations?.[0]
 
-  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
-  }
+      // const foo = () => {}
+      if (
+        decl &&
+        ts.isVariableDeclaration(decl) &&
+        decl.initializer &&
+        (ts.isArrowFunction(decl.initializer) ||
+          ts.isFunctionExpression(decl.initializer))
+      ) {
+        return decl.initializer
+      }
 
-  if (inputIndex !== undefined && inputIndex < typeArguments.length) {
-    const { names, types } = getNamesAndTypes(
-      checker,
-      typesMap,
-      'Input',
-      funcName,
-      typeArguments[inputIndex]!
-    )
-    result.inputs = names
-    result.inputTypes = types
-  } else {
-    console.log(`No input defined for ${funcName}`)
-  }
+      // function foo() {}
+      if (
+        decl &&
+        (ts.isFunctionDeclaration(decl) ||
+          ts.isArrowFunction(decl) ||
+          ts.isFunctionExpression(decl))
+      ) {
+        return decl as ts.Expression
+      }
 
-  if (outputIndex !== undefined && outputIndex < typeArguments.length) {
-    const { names, types } = getNamesAndTypes(
-      checker,
-      typesMap,
-      'Output',
-      funcName,
-      typeArguments[outputIndex]!
-    )
-    result.outputs = names
-    result.outputTypes = types
-  } else {
-    console.info(`No output defined for ${funcName}`)
+      // fallback – just give back the identifier
+      return prop.name
+    }
   }
 
-  return result
+  return undefined
 }
 
 export const matchesFilters = (