@hyperframes/parsers 0.8.30 → 0.8.32

package/dist/gsapParser.js

@@ -557,19 +557,82 @@ function addBinding(bindings, scopeNode, name, selector) {
   }
   if (!scoped.has(name)) scoped.set(name, selector);
 }
-function collectTargetBindings(ast, scope) {
+function directHelperReturn(node) {
+  if (node.type === "ArrowFunctionExpression" && node.body?.type !== "BlockStatement") {
+    return node.body;
+  }
+  if (!isFunctionNode(node) || node.body?.type !== "BlockStatement") return null;
+  const returns = (node.body.body ?? []).filter(
+    (statement) => statement.type === "ReturnStatement" && statement.argument
+  );
+  return returns.length === 1 ? returns[0].argument : null;
+}
+function collectTargetHelpers(ast) {
+  const helpers = /* @__PURE__ */ new Map();
+  const add = (scopeNode, name, fn) => {
+    const returnNode = directHelperReturn(fn);
+    const params = (fn.params ?? []).filter((param) => param.type === "Identifier").map((param) => param.name);
+    if (!returnNode || params.length !== (fn.params?.length ?? 0)) return;
+    let scoped = helpers.get(scopeNode);
+    if (!scoped) {
+      scoped = /* @__PURE__ */ new Map();
+      helpers.set(scopeNode, scoped);
+    }
+    if (!scoped.has(name)) scoped.set(name, { params, returnNode });
+  };
+  recast.types.visit(ast, {
+    visitFunctionDeclaration(path) {
+      const name = path.node.id?.name;
+      const scopeNode = enclosingScopeNode(path);
+      if (name && scopeNode) add(scopeNode, name, path.node);
+      this.traverse(path);
+    },
+    visitVariableDeclarator(path) {
+      const name = path.node.id?.name;
+      const fn = path.node.init;
+      const scopeNode = enclosingScopeNode(path);
+      if (name && fn && isFunctionNode(fn) && scopeNode) add(scopeNode, name, fn);
+      this.traverse(path);
+    }
+  });
+  return helpers;
+}
+function lookupTargetHelper(name, path, helpers) {
+  for (const scopeNode of scopeChainOf(path)) {
+    const helper = helpers.get(scopeNode)?.get(name);
+    if (helper) return helper;
+  }
+  return null;
+}
+function selectorFromTargetCall(node, path, scope, helpers) {
+  const direct = selectorFromQueryCall(node, scope);
+  if (direct) return direct;
+  if (node?.type !== "CallExpression" || node.callee?.type !== "Identifier") return null;
+  const helper = lookupTargetHelper(node.callee.name, path, helpers);
+  if (!helper || helper.params.length !== (node.arguments?.length ?? 0)) return null;
+  const helperScope = new Map(scope);
+  for (let i = 0; i < helper.params.length; i += 1) {
+    const param = helper.params[i];
+    if (!param) return null;
+    const value = resolveNode(node.arguments[i], scope);
+    if (value === void 0) return null;
+    helperScope.set(param, value);
+  }
+  return selectorFromQueryCall(helper.returnNode, helperScope);
+}
+function collectTargetBindings(ast, scope, helpers) {
   const bindings = /* @__PURE__ */ new Map();
   recast.types.visit(ast, {
     visitVariableDeclarator(path) {
       const name = path.node.id?.name;
-      const selector = selectorFromQueryCall(path.node.init, scope);
+      const selector = selectorFromTargetCall(path.node.init, path, scope, helpers);
       const scopeNode = enclosingScopeNode(path);
       if (name && selector !== null && scopeNode) addBinding(bindings, scopeNode, name, selector);
       this.traverse(path);
     },
     visitAssignmentExpression(path) {
       const left = path.node.left;
-      const selector = selectorFromQueryCall(path.node.right, scope);
+      const selector = selectorFromTargetCall(path.node.right, path, scope, helpers);
       const scopeNode = enclosingScopeNode(path);
       if (left?.type === "Identifier" && selector !== null && scopeNode) {
         addBinding(bindings, scopeNode, left.name, selector);
@@ -609,7 +672,7 @@ function lookupBinding(name, path, bindings) {
   }
   return null;
 }
-function resolveTargetSelector(node, path, scope, bindings) {
+function resolveTargetSelector(node, path, scope, bindings, helpers) {
   if (!node) return null;
   if (node.type === "StringLiteral" || node.type === "Literal") {
     return typeof node.value === "string" ? node.value : null;
@@ -618,10 +681,10 @@ function resolveTargetSelector(node, path, scope, bindings) {
     return lookupBinding(node.name, path, bindings);
   }
   if (node.type === "CallExpression") {
-    return selectorFromQueryCall(node, scope);
+    return selectorFromTargetCall(node, path, scope, helpers);
   }
   if (node.type === "ArrayExpression") {
-    const parts = node.elements.map((el) => resolveTargetSelector(el, path, scope, bindings)).filter((s) => typeof s === "string" && s.length > 0);
+    const parts = node.elements.map((el) => resolveTargetSelector(el, path, scope, bindings, helpers)).filter((s) => typeof s === "string" && s.length > 0);
     return parts.length > 0 ? parts.join(", ") : null;
   }
   if (node.type === "MemberExpression" && node.object?.type === "Identifier") {
@@ -736,7 +799,7 @@ function isTimelineRootedCall(callNode, ref) {
   if (ref.kind === "identifier") return obj?.type === "Identifier" && obj.name === ref.name;
   return sameMemberAccess(obj, ref.node);
 }
-function findAllTweenCalls(ast, ref, scope, targetBindings) {
+function findAllTweenCalls(ast, ref, scope, targetBindings, targetHelpers) {
   const results = [];
   recast.types.visit(ast, {
     visitCallExpression(path) {
@@ -755,7 +818,7 @@ function findAllTweenCalls(ast, ref, scope, targetBindings) {
           this.traverse(path);
           return;
         }
-        const selectorValue = resolveTargetSelector(args[0], path, scope, targetBindings) ?? "__unresolved__";
+        const selectorValue = resolveTargetSelector(args[0], path, scope, targetBindings, targetHelpers) ?? "__unresolved__";
         if (method === "fromTo") {
           results.push({
             path,
@@ -1208,11 +1271,12 @@ function assignStableIds(anims) {
 function parseGsapAst(script) {
   const ast = parseScript(script);
   const scope = collectScopeBindings(ast);
-  const targetBindings = collectTargetBindings(ast, scope);
+  const targetHelpers = collectTargetHelpers(ast);
+  const targetBindings = collectTargetBindings(ast, scope, targetHelpers);
   const detection = findTimelineVar(ast, scope);
   const ref = detection.ref ?? { kind: "identifier", name: "tl" };
   const timelineVar = timelineRootSource(ref);
-  const calls = findAllTweenCalls(ast, ref, scope, targetBindings);
+  const calls = findAllTweenCalls(ast, ref, scope, targetBindings, targetHelpers);
   sortBySourcePosition(calls);
   const rawAnims = calls.map((call) => tweenCallToAnimation(call, scope));
   applyTimelineDefaults(rawAnims, detection.defaults);