@pikku/inspector 0.12.21 → 0.12.22

package/src/utils/extract-node-value.test.ts

@@ -1,7 +1,7 @@
 import { test, describe } from 'node:test'
 import { strict as assert } from 'node:assert'
 import * as ts from 'typescript'
-import { extractDescription } from './extract-node-value'
+import { extractDescription, extractStringLiteral } from './extract-node-value'
 
 const createChecker = (source: string) => {
   const sourceFile = ts.createSourceFile(
@@ -67,3 +67,51 @@ describe('extractDescription', () => {
     assert.equal(extractDescription(sourceFile, checker), null)
   })
 })
+
+describe('extractStringLiteral — concatenation/template symmetry', () => {
+  const findInitializer = (node: ts.Node): ts.Expression | undefined => {
+    if (ts.isVariableDeclaration(node) && node.initializer) {
+      return node.initializer
+    }
+    let result: ts.Expression | undefined
+    ts.forEachChild(node, (child) => {
+      if (!result) result = findInitializer(child)
+    })
+    return result
+  }
+
+  test('a `+` operand that cannot be statically resolved becomes a ${...} placeholder', () => {
+    const { checker, sourceFile } = createChecker(
+      `const x = 'Enrich event ' + (event.id ?? event.name)`
+    )
+    const init = findInitializer(sourceFile)!
+    assert.equal(
+      extractStringLiteral(init, checker),
+      'Enrich event ${event.id ?? event.name}'
+    )
+  })
+
+  test('`+` concatenation and template literal produce the same display string', () => {
+    const concat = createChecker(
+      `const x = 'Enrich event ' + (event.id ?? event.name)`
+    )
+    const template = createChecker(
+      'const x = `Enrich event ${event.id ?? event.name}`'
+    )
+    const concatValue = extractStringLiteral(
+      findInitializer(concat.sourceFile)!,
+      concat.checker
+    )
+    const templateValue = extractStringLiteral(
+      findInitializer(template.sourceFile)!,
+      template.checker
+    )
+    assert.equal(concatValue, templateValue)
+  })
+
+  test('still resolves fully-static concatenation exactly', () => {
+    const { checker, sourceFile } = createChecker(`const x = 'a' + 'b' + 'c'`)
+    const init = findInitializer(sourceFile)!
+    assert.equal(extractStringLiteral(init, checker), 'abc')
+  })
+})

package/src/utils/extract-node-value.ts

@@ -37,8 +37,8 @@ export function extractStringLiteral(
     node.operatorToken.kind === ts.SyntaxKind.PlusToken
   ) {
     return (
-      extractStringLiteral(node.left, checker) +
-      extractStringLiteral(node.right, checker)
+      extractConcatOperand(node.left, checker) +
+      extractConcatOperand(node.right, checker)
     )
   }
 
@@ -59,6 +59,23 @@ export function extractStringLiteral(
   throw new Error('Unable to extract string literal from node')
 }
 
+/**
+ * Resolve one operand of a `+` string concatenation.
+ *
+ * An operand that can't be statically resolved (e.g. `a ?? b`) becomes a
+ * `${...}` placeholder rather than throwing — mirroring the TemplateExpression
+ * branch above, so `'x ' + expr` and `` `x ${expr}` `` produce the same string.
+ * This keeps an unresolvable display name from aborting the whole extraction.
+ */
+function extractConcatOperand(node: ts.Node, checker: ts.TypeChecker): string {
+  try {
+    return extractStringLiteral(node, checker)
+  } catch {
+    const inner = ts.isParenthesizedExpression(node) ? node.expression : node
+    return '${' + inner.getText() + '}'
+  }
+}
+
 /**
  * Check if node is string-like (string literal or template expression)
  */

package/src/utils/filter-inspector-state.test.ts

@@ -344,6 +344,7 @@ const mockLogger = {
   error: () => {},
   warn: () => {},
   debug: () => {},
+  diagnostic: () => {},
   critical: () => {},
   hasCriticalErrors: () => false,
 }

package/src/utils/filter-utils.test.ts

@@ -10,6 +10,7 @@ describe('matchesFilters', () => {
     error: () => {},
     warn: () => {},
     debug: () => {},
+    diagnostic: () => {},
     critical: () => {},
     hasCriticalErrors: () => false,
   }

package/src/utils/resolve-versions.test.ts

@@ -43,6 +43,7 @@ function makeLogger() {
       info: () => {},
       warn: () => {},
       error: (msg: string) => errors.push(msg),
+      diagnostic: ({ message }: { message: string }) => errors.push(message),
       critical: (_code: string, msg: string) => errors.push(msg),
     },
     errors,

package/src/utils/workflow/dsl/extract-dsl-workflow.ts

@@ -386,6 +386,22 @@ function extractVariableDeclaration(
         return step
       }
     }
+
+    // Promise.all fanout/group captured into a variable
+    // (const results = await Promise.all(array.map(...)))
+    if (isParallelFanout(call) || isParallelGroup(call)) {
+      const step = isParallelFanout(call)
+        ? extractParallelFanout(call, context)
+        : extractParallelGroup(call, context)
+      if (step) {
+        const type = context.checker.getTypeAtLocation(decl)
+        context.outputVars.set(varName, { type, node: decl })
+        if (isArrayType(type, context.checker)) {
+          context.arrayVars.add(varName)
+        }
+        return step
+      }
+    }
   }
 
   // Check for array.filter(...)