@pikku/inspector 0.9.5 → 0.10.0

package/dist/{utils.js → utils/extract-function-name.js}

@@ -1,10 +1,11 @@
 import * as ts from 'typescript';
+import { toRelativePath } from './find-root-dir.js';
 /**
  * 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) {
+export function makeDeterministicAnonName(start, checker, rootDir) {
     let node = start;
     let target = start;
     // Handle the case where we're starting with an identifier directly
@@ -27,7 +28,8 @@ export function makeDeterministicAnonName(start, checker) {
                     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 relativePath = toRelativePath(sf.fileName, rootDir);
+                    const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_');
                     const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
                     return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
                 }
@@ -62,7 +64,8 @@ export function makeDeterministicAnonName(start, checker) {
                         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 relativePath = toRelativePath(sf.fileName, rootDir);
+                        const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_');
                         const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
                         return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
                     }
@@ -72,7 +75,8 @@ export function makeDeterministicAnonName(start, checker) {
                     target = decl;
                     // Return early
                     const sf = target.getSourceFile();
-                    const file = sf.fileName.replace(/[^A-Za-z0-9_]/g, '_');
+                    const relativePath = toRelativePath(sf.fileName, rootDir);
+                    const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_');
                     const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
                     return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
                 }
@@ -182,7 +186,8 @@ export function makeDeterministicAnonName(start, checker) {
             break;
     }
     const sf = target.getSourceFile();
-    const file = sf.fileName.replace(/[^A-Za-z0-9_]/g, '_');
+    const relativePath = toRelativePath(sf.fileName, rootDir);
+    const file = relativePath.replace(/[^A-Za-z0-9_]/g, '_');
     const { line, character } = ts.getLineAndCharacterOfPosition(sf, target.getStart());
     return `pikkuFn_${file}_L${line + 1}C${character + 1}`;
 }
@@ -193,7 +198,7 @@ export function makeDeterministicAnonName(start, checker) {
  * 2. Exported name
  * 3. Fallback to deterministic name
  */
-export function extractFunctionName(callExpr, checker) {
+export function extractFunctionName(callExpr, checker, rootDir) {
     const parent = callExpr.parent;
     // Initialize the result
     const result = {
@@ -230,7 +235,7 @@ export function extractFunctionName(callExpr, checker) {
                             (ts.isArrowFunction(firstArg) ||
                                 ts.isFunctionExpression(firstArg))) {
                             // Use the function directly for position calculation
-                            result.pikkuFuncName = makeDeterministicAnonName(firstArg, checker);
+                            result.pikkuFuncName = makeDeterministicAnonName(firstArg, checker, rootDir);
                             // Continue with name extraction
                             if (ts.isIdentifier(parent.name)) {
                                 result.propertyName = parent.name.text;
@@ -256,9 +261,8 @@ export function extractFunctionName(callExpr, checker) {
             }
         }
     }
-    // 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
+    // Keep track of the original call expression for position-based naming
+    let originalCallExpr = callExpr;
     // For direct pikku function calls where callExpr is the call expression itself
     if (ts.isCallExpression(callExpr)) {
         const { expression, arguments: args } = callExpr;
@@ -284,7 +288,7 @@ export function extractFunctionName(callExpr, checker) {
                     const firstArg = args[0];
                     if (ts.isArrowFunction(firstArg) ||
                         ts.isFunctionExpression(firstArg)) {
-                        mainFunc = firstArg; // Use the arrow function directly instead of the call expression
+                        // mainFunc = firstArg // Use the arrow function directly instead of the call expression
                     }
                 }
             }
@@ -321,7 +325,7 @@ export function extractFunctionName(callExpr, checker) {
                                             if (firstArg &&
                                                 (ts.isArrowFunction(firstArg) ||
                                                     ts.isFunctionExpression(firstArg))) {
-                                                mainFunc = firstArg;
+                                                // mainFunc = firstArg
                                                 // Check if the variable is exported
                                                 if (isNamedExport(funcDecl) &&
                                                     ts.isIdentifier(funcDecl.name)) {
@@ -336,7 +340,7 @@ export function extractFunctionName(callExpr, checker) {
                                         }
                                         else if (ts.isFunctionExpression(funcDecl.initializer) ||
                                             ts.isArrowFunction(funcDecl.initializer)) {
-                                            mainFunc = funcDecl.initializer;
+                                            // mainFunc = funcDecl.initializer
                                             // Check if the variable is exported
                                             if (isNamedExport(funcDecl) &&
                                                 ts.isIdentifier(funcDecl.name)) {
@@ -350,7 +354,7 @@ export function extractFunctionName(callExpr, checker) {
                                         }
                                     }
                                     else if (ts.isFunctionDeclaration(funcDecl)) {
-                                        mainFunc = funcDecl;
+                                        // mainFunc = funcDecl
                                         // Check if the function is exported
                                         if (funcDecl.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
                                             funcDecl.name &&
@@ -368,14 +372,14 @@ export function extractFunctionName(callExpr, checker) {
                             }
                             else {
                                 // If we can't resolve the symbol, use the identifier itself
-                                mainFunc = prop.initializer;
+                                // mainFunc = prop.initializer
                             }
                             break;
                         }
                         else if (ts.isFunctionExpression(prop.initializer) ||
                             ts.isArrowFunction(prop.initializer)) {
                             // func: () => {} or func: function() {} - use directly
-                            mainFunc = prop.initializer;
+                            // mainFunc = prop.initializer
                             break;
                         }
                     }
@@ -401,7 +405,7 @@ export function extractFunctionName(callExpr, checker) {
                                     if (firstArg &&
                                         (ts.isArrowFunction(firstArg) ||
                                             ts.isFunctionExpression(firstArg))) {
-                                        mainFunc = firstArg;
+                                        // mainFunc = firstArg
                                         // Check if the variable is exported
                                         if (isNamedExport(shorthandDecl) &&
                                             ts.isIdentifier(shorthandDecl.name)) {
@@ -416,7 +420,7 @@ export function extractFunctionName(callExpr, checker) {
                                 }
                                 else if (ts.isFunctionExpression(shorthandDecl.initializer) ||
                                     ts.isArrowFunction(shorthandDecl.initializer)) {
-                                    mainFunc = shorthandDecl.initializer;
+                                    // mainFunc = shorthandDecl.initializer
                                     // Check if the variable is exported
                                     if (isNamedExport(shorthandDecl) &&
                                         ts.isIdentifier(shorthandDecl.name)) {
@@ -430,7 +434,7 @@ export function extractFunctionName(callExpr, checker) {
                                 }
                             }
                             else if (ts.isFunctionDeclaration(shorthandDecl)) {
-                                mainFunc = shorthandDecl;
+                                // mainFunc = shorthandDecl
                                 // Check if the function is exported
                                 if (shorthandDecl.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
                                     shorthandDecl.name &&
@@ -468,6 +472,9 @@ export function extractFunctionName(callExpr, checker) {
                     if (ts.isCallExpression(decl.initializer) &&
                         ts.isIdentifier(decl.initializer.expression) &&
                         decl.initializer.expression.text.startsWith('pikku')) {
+                        // Update originalCallExpr to use the call expression position
+                        // instead of the variable declaration position
+                        originalCallExpr = decl.initializer;
                         // Check for object with 'name' property in first argument
                         const firstArg = decl.initializer.arguments[0];
                         if (firstArg && ts.isObjectLiteralExpression(firstArg)) {
@@ -486,7 +493,7 @@ export function extractFunctionName(callExpr, checker) {
                             if (firstArg &&
                                 (ts.isArrowFunction(firstArg) ||
                                     ts.isFunctionExpression(firstArg))) {
-                                mainFunc = firstArg;
+                                // mainFunc = firstArg
                             }
                         }
                         // Check if the variable is exported
@@ -502,7 +509,7 @@ export function extractFunctionName(callExpr, checker) {
                     }
                     else if (ts.isFunctionExpression(decl.initializer) ||
                         ts.isArrowFunction(decl.initializer)) {
-                        mainFunc = decl.initializer;
+                        // mainFunc = decl.initializer
                         // Check if the variable is exported
                         if (isNamedExport(decl) && ts.isIdentifier(decl.name)) {
                             result.exportedName = decl.name.text;
@@ -513,7 +520,7 @@ export function extractFunctionName(callExpr, checker) {
                     }
                 }
                 else if (ts.isFunctionDeclaration(decl)) {
-                    mainFunc = decl;
+                    // mainFunc = decl
                     // Check if the function is exported
                     if (decl.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) &&
                         decl.name &&
@@ -527,8 +534,10 @@ export function extractFunctionName(callExpr, checker) {
             }
         }
     }
-    // Now generate the deterministic function name based on the resolved function
-    result.pikkuFuncName = makeDeterministicAnonName(mainFunc, checker);
+    // Generate the deterministic function name based on the original call expression
+    // (the config), not the resolved inner function. This ensures the metadata key
+    // matches what will be looked up at runtime when referencing the config object.
+    result.pikkuFuncName = makeDeterministicAnonName(originalCallExpr, checker, rootDir);
     // Continue with regular name extraction for remaining cases
     // 1) const foo = pikkuFunc(...)
     if (ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
@@ -577,7 +586,7 @@ export function extractFunctionName(callExpr, checker) {
 /**
  * Helper function to populate the 'name' field based on priority
  */
-function populateNameByPriority(result) {
+export function populateNameByPriority(result) {
     // Priority 1: If we have an explict name, use that
     if (result.explicitName) {
         result.name = result.explicitName;
@@ -599,7 +608,7 @@ function populateNameByPriority(result) {
 /**
  * Helper function to check if a variable declaration is a named export
  */
-function isNamedExport(declaration) {
+export function isNamedExport(declaration) {
     let parent = declaration.parent;
     if (!parent)
         return false;
@@ -616,126 +625,3 @@ function isNamedExport(declaration) {
     }
     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, logger) => {
-    // If no filters are provided, allow everything
-    if (Object.keys(filters).length === 0) {
-        return true;
-    }
-    // If all filter arrays are empty, allow everything
-    if ((!filters.tags || filters.tags.length === 0) &&
-        (!filters.types || filters.types.length === 0) &&
-        (!filters.directories || filters.directories.length === 0)) {
-        return true;
-    }
-    // Check type filter
-    if (filters.types && filters.types.length > 0) {
-        if (!filters.types.includes(meta.type)) {
-            logger.debug(`⒡ Filtered by type: ${meta.type}:${meta.name}`);
-            return false;
-        }
-    }
-    // Check directory filter
-    if (filters.directories && filters.directories.length > 0) {
-        if (!meta.filePath) {
-            logger.debug(`⒡ Filtered by directory: ${meta.type}:${meta.name} (${meta.filePath})`);
-            return false;
-        }
-        const matchesDirectory = filters.directories.some((dir) => {
-            // Normalize paths for comparison
-            const normalizedFilePath = meta.filePath.replace(/\\/g, '/');
-            const normalizedDir = dir.replace(/\\/g, '/');
-            return normalizedFilePath.includes(normalizedDir);
-        });
-        if (!matchesDirectory) {
-            logger.debug(`⒡ Filtered by directory: ${meta.type}:${meta.name} (${meta.filePath})`);
-            return false;
-        }
-    }
-    // Check tag filter
-    if (filters.tags && filters.tags.length > 0) {
-        if (!params.tags ||
-            !filters.tags.some((tag) => params.tags.includes(tag))) {
-            logger.debug(`⒡ Filtered by tags: ${meta.type}:${meta.name}`);
-            return false;
-        }
-    }
-    return true;
-};
-/**
- * Extract services from a function's first parameter destructuring pattern
- */
-export function extractServicesFromFunction(handlerNode) {
-    const services = {
-        optimized: true,
-        services: [],
-    };
-    const firstParam = handlerNode.parameters[0];
-    if (firstParam) {
-        if (ts.isObjectBindingPattern(firstParam.name)) {
-            for (const elem of firstParam.name.elements) {
-                const original = elem.propertyName && ts.isIdentifier(elem.propertyName)
-                    ? elem.propertyName.text
-                    : ts.isIdentifier(elem.name)
-                        ? elem.name.text
-                        : undefined;
-                if (original) {
-                    services.services.push(original);
-                }
-            }
-        }
-        else if (ts.isIdentifier(firstParam.name)) {
-            services.optimized = false;
-        }
-    }
-    return services;
-}

package/dist/utils/extract-services.d.ts

@@ -0,0 +1,6 @@
+import * as ts from 'typescript';
+import { FunctionServicesMeta } from '@pikku/core';
+/**
+ * Extract services from a function's first parameter destructuring pattern
+ */
+export declare function extractServicesFromFunction(handlerNode: ts.FunctionExpression | ts.ArrowFunction): FunctionServicesMeta;

package/dist/utils/extract-services.js

@@ -0,0 +1,29 @@
+import * as ts from 'typescript';
+/**
+ * Extract services from a function's first parameter destructuring pattern
+ */
+export function extractServicesFromFunction(handlerNode) {
+    const services = {
+        optimized: true,
+        services: [],
+    };
+    const firstParam = handlerNode.parameters[0];
+    if (firstParam) {
+        if (ts.isObjectBindingPattern(firstParam.name)) {
+            for (const elem of firstParam.name.elements) {
+                const original = elem.propertyName && ts.isIdentifier(elem.propertyName)
+                    ? elem.propertyName.text
+                    : ts.isIdentifier(elem.name)
+                        ? elem.name.text
+                        : undefined;
+                if (original) {
+                    services.services.push(original);
+                }
+            }
+        }
+        else if (ts.isIdentifier(firstParam.name)) {
+            services.optimized = false;
+        }
+    }
+    return services;
+}

package/dist/utils/filter-inspector-state.d.ts

@@ -0,0 +1,6 @@
+import { InspectorState, InspectorFilters, InspectorLogger } from '../types.js';
+/**
+ * Filters inspector state based on provided filters
+ * This is applied post-inspection to support the inspect-once, filter-many pattern
+ */
+export declare function filterInspectorState(state: InspectorState | Omit<InspectorState, 'typesLookup'>, filters: InspectorFilters, logger: InspectorLogger): typeof state;