fix: handle filter projections with array field access

Fixes issue where expressions like [?stack==''].branch[?starts_with(@, 'one')] would fail with invalid-type error.

The FilterProjection interpreter now correctly handles array-of-arrays by applying filters to sub-elements while maintaining projection structure.

Fixes #23

<!-- ps-id: 01fb2a2e-8823-477c-b9d2-1dadc433b26a -->

Author: cawalch

src/TreeInterpreter.ts

@@ -165,6 +165,43 @@ export class TreeInterpreter {
           return null;
         }
 
+        // Check if we need to handle array-of-arrays case for proper filter projection
+        // where the left side returns an array of arrays that should be processed
+        // as a projection over each sub-array
+        const hasArrayElements = base.some(elem => Array.isArray(elem));
+        if (hasArrayElements) {
+          // If some elements are arrays, we need to apply the filter to each sub-array
+          // and collect the results, maintaining the projection structure
+          const results: JSONArray = [];
+          for (const elem of base) {
+            if (Array.isArray(elem)) {
+              const subResults: JSONArray = [];
+              for (const subElem of elem) {
+                const matched = this.visit(condition, subElem);
+                if (isFalse(matched)) {
+                  continue;
+                }
+                const result = this.visit(right, subElem) as JSONValue;
+                if (result !== null) {
+                  subResults.push(result);
+                }
+              }
+              results.push(subResults);
+            } else {
+              // For non-array elements, apply the filter directly
+              const matched = this.visit(condition, elem);
+              if (!isFalse(matched)) {
+                const result = this.visit(right, elem) as JSONValue;
+                if (result !== null) {
+                  results.push(result);
+                }
+              }
+            }
+          }
+          return results;
+        }
+
+        // Standard filter projection for non-nested arrays
         const results: JSONArray = [];
         for (const elem of base) {
           const matched = this.visit(condition, elem);

test/jmespath-interpreter.spec.ts

@@ -5,4 +5,20 @@ describe('Searches compiled ast', () => {
   it('search a compiled expression', () => {
     expect(search({ foo: { bar: 'BAZ' } }, 'foo.bar')).toEqual('BAZ');
   });
+
+  it('handles filter projections with array field access', () => {
+    const data = [
+      {
+        stack: '',
+        branch: ['one/', 'two/'],
+      },
+      {
+        stack: null,
+        branch: ['three/', 'four/'],
+      },
+    ];
+
+    const result = search(data, "[?stack==''].branch[?starts_with(@, 'one')]");
+    expect(result).toEqual([['one/']]);
+  });
 });