@agent-scope/babel-plugin 1.0.1

package/dist/index.cjs

@@ -0,0 +1,553 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// src/utils/ast-helpers.ts
+function isComponentName(name) {
+  return /^[A-Z]/.test(name);
+}
+function isJSXNode(node) {
+  return node.type === "JSXElement" || node.type === "JSXFragment";
+}
+function bodyContainsJSX(node) {
+  for (const stmt of node.body) {
+    if (stmt.type === "ReturnStatement" && stmt.argument && isJSXNode(stmt.argument)) {
+      return true;
+    }
+    if (stmt.type === "ReturnStatement" && stmt.argument) {
+      if (containsJSXExpression(stmt.argument)) return true;
+    }
+  }
+  return false;
+}
+function containsJSXExpression(node) {
+  if (isJSXNode(node)) return true;
+  if (node.type === "ConditionalExpression") {
+    return containsJSXExpression(node.consequent) || containsJSXExpression(node.alternate);
+  }
+  if (node.type === "LogicalExpression") {
+    return containsJSXExpression(node.left) || containsJSXExpression(node.right);
+  }
+  if (node.type === "ParenthesizedExpression") {
+    return containsJSXExpression(node.expression);
+  }
+  return false;
+}
+function isReactMemoCall(node) {
+  const callee = node.callee;
+  if (callee.type === "Identifier" && callee.name === "memo") return true;
+  if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "React" && callee.property.type === "Identifier" && callee.property.name === "memo") {
+    return true;
+  }
+  return false;
+}
+function isReactForwardRefCall(node) {
+  const callee = node.callee;
+  if (callee.type === "Identifier" && callee.name === "forwardRef") return true;
+  if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "React" && callee.property.type === "Identifier" && callee.property.name === "forwardRef") {
+    return true;
+  }
+  return false;
+}
+
+// src/visitors/component-detector.ts
+function detectFunctionDeclaration(node) {
+  if (!node.id || !isComponentName(node.id.name)) return null;
+  if (!node.body || !bodyContainsJSX(node.body)) return null;
+  const loc = node.loc?.start ?? { line: 0, column: 0 };
+  return {
+    name: node.id.name,
+    line: loc.line,
+    column: loc.column,
+    bindingIdentifierName: node.id.name
+  };
+}
+function detectVariableDeclaration(node) {
+  for (const declarator of node.declarations) {
+    if (declarator.id.type !== "Identifier") continue;
+    const name = declarator.id.name;
+    if (!isComponentName(name)) continue;
+    if (!declarator.init) continue;
+    if (isFunctionReturningJSX(declarator.init)) {
+      const loc = node.loc?.start ?? { line: 0, column: 0 };
+      return { name, line: loc.line, column: loc.column, bindingIdentifierName: name };
+    }
+    if (declarator.init.type === "CallExpression" && (isReactMemoCall(declarator.init) || isReactForwardRefCall(declarator.init))) {
+      const loc = node.loc?.start ?? { line: 0, column: 0 };
+      return { name, line: loc.line, column: loc.column, bindingIdentifierName: name };
+    }
+  }
+  return null;
+}
+function isFunctionReturningJSX(node) {
+  if (node.type === "ArrowFunctionExpression") {
+    if (node.body.type !== "BlockStatement") {
+      return containsJSXExpression(node.body);
+    }
+    return bodyContainsJSX(node.body);
+  }
+  if (node.type === "FunctionExpression") {
+    if (!node.body) return false;
+    return bodyContainsJSX(node.body);
+  }
+  return false;
+}
+
+// src/visitors/prop-type-extractor.ts
+function resolvePropType(node) {
+  switch (node.type) {
+    case "TSStringKeyword":
+      return "string";
+    case "TSNumberKeyword":
+      return "number";
+    case "TSBooleanKeyword":
+      return "boolean";
+    case "TSVoidKeyword":
+    case "TSUndefinedKeyword":
+    case "TSNullKeyword":
+    case "TSNeverKeyword":
+    case "TSAnyKeyword":
+    case "TSUnknownKeyword":
+      return "unknown";
+    case "TSArrayType":
+    case "TSTupleType":
+      return "array";
+    case "TSTypeLiteral":
+    case "TSMappedType":
+      return "object";
+    case "TSFunctionType":
+    case "TSConstructorType":
+      return "function";
+    case "TSTypeReference": {
+      const typeName = resolveTypeReferenceName(node);
+      if (typeName === "ReactNode" || typeName === "React.ReactNode" || typeName === "ReactElement" || typeName === "React.ReactElement") {
+        return "ReactNode";
+      }
+      if (typeName === "MouseEvent" || typeName === "KeyboardEvent" || typeName === "ChangeEvent" || typeName === "FocusEvent" || typeName === "SyntheticEvent" || typeName === "EventHandler" || typeName?.startsWith("React.") && typeName.endsWith("Handler")) {
+        return "function";
+      }
+      return "unknown";
+    }
+    case "TSUnionType": {
+      const members = node.types;
+      if (members.length > 0 && members.every((m) => m.type === "TSLiteralType")) {
+        return "union";
+      }
+      return "unknown";
+    }
+    case "TSIntersectionType":
+    case "TSConditionalType":
+    case "TSIndexedAccessType":
+    case "TSTypeQuery":
+    case "TSTemplateLiteralType":
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+function resolveTypeReferenceName(node) {
+  const { typeName } = node;
+  if (typeName.type === "Identifier") return typeName.name;
+  if (typeName.type === "TSQualifiedName") {
+    const left = typeName.left.type === "Identifier" ? typeName.left.name : "";
+    return `${left}.${typeName.right.name}`;
+  }
+  return void 0;
+}
+function extractLiterals(unionNode) {
+  const values = [];
+  for (const member of unionNode.types) {
+    if (member.type !== "TSLiteralType") return void 0;
+    const lit = member.literal;
+    if (lit.type === "StringLiteral") {
+      values.push(lit.value);
+    } else if (lit.type === "NumericLiteral") {
+      values.push(String(lit.value));
+    } else {
+      return void 0;
+    }
+  }
+  return values.length > 0 ? values : void 0;
+}
+function extractDefaultValues(params) {
+  const defaults = {};
+  if (params.length === 0) return defaults;
+  const firstParam = params[0];
+  if (!firstParam) return defaults;
+  let pattern = null;
+  if (firstParam.type === "ObjectPattern") {
+    pattern = firstParam;
+  } else if (firstParam.type === "AssignmentPattern" && firstParam.left.type === "ObjectPattern") {
+    pattern = firstParam.left;
+  }
+  if (pattern?.type === "ObjectPattern") {
+    for (const prop of pattern.properties) {
+      if (prop.type !== "ObjectProperty") continue;
+      if (prop.key.type !== "Identifier") continue;
+      const propName = prop.key.name;
+      if (prop.value.type === "AssignmentPattern") {
+        const defaultNode = prop.value.right;
+        const extracted = extractLiteralValue(defaultNode);
+        if (extracted !== void 0) {
+          defaults[propName] = extracted;
+        }
+      }
+    }
+  }
+  return defaults;
+}
+function extractLiteralValue(node) {
+  if (node.type === "StringLiteral") return node.value;
+  if (node.type === "NumericLiteral") return node.value;
+  if (node.type === "BooleanLiteral") return node.value;
+  if (node.type === "NullLiteral") return null;
+  if (node.type === "UnaryExpression" && node.operator === "-" && node.argument.type === "NumericLiteral") {
+    return -node.argument.value;
+  }
+  return void 0;
+}
+function extractPropsFromTypeMembers(members, defaults) {
+  const props = {};
+  for (const member of members) {
+    if (member.type !== "TSPropertySignature") continue;
+    if (member.key.type !== "Identifier") continue;
+    const propName = member.key.name;
+    const required = !member.optional;
+    if (!member.typeAnnotation) {
+      props[propName] = { type: "unknown", required };
+      continue;
+    }
+    const tsType = member.typeAnnotation.typeAnnotation;
+    let propType = resolvePropType(tsType);
+    let values;
+    if (tsType.type === "TSUnionType") {
+      const literals = extractLiterals(tsType);
+      if (literals) {
+        propType = "union";
+        values = literals;
+      }
+    }
+    const meta = { type: propType, required };
+    if (values) meta.values = values;
+    const defaultVal = defaults[propName];
+    if (defaultVal !== void 0) meta.defaultValue = defaultVal;
+    props[propName] = meta;
+  }
+  return props;
+}
+
+// src/visitors/props-injector.ts
+function buildPrimitiveLiteral(t, value) {
+  if (typeof value === "string") return t.stringLiteral(value);
+  if (typeof value === "number") return t.numericLiteral(value);
+  if (typeof value === "boolean") return t.booleanLiteral(value);
+  if (value === null) return t.nullLiteral();
+  return t.stringLiteral(String(value));
+}
+function buildPropMetaObject(t, meta) {
+  const props = [
+    t.objectProperty(t.identifier("type"), t.stringLiteral(meta.type)),
+    t.objectProperty(t.identifier("required"), t.booleanLiteral(meta.required))
+  ];
+  if (meta.values !== void 0) {
+    props.push(
+      t.objectProperty(
+        t.identifier("values"),
+        t.arrayExpression(meta.values.map((v) => t.stringLiteral(v)))
+      )
+    );
+  }
+  if (meta.defaultValue !== void 0) {
+    props.push(
+      t.objectProperty(t.identifier("defaultValue"), buildPrimitiveLiteral(t, meta.defaultValue))
+    );
+  }
+  return t.objectExpression(props);
+}
+function buildScopePropsStatement(t, name, props) {
+  const entries = Object.entries(props).map(
+    ([key, meta]) => t.objectProperty(t.identifier(key), buildPropMetaObject(t, meta))
+  );
+  return t.expressionStatement(
+    t.assignmentExpression(
+      "=",
+      t.memberExpression(t.identifier(name), t.identifier("__scopeProps")),
+      t.objectExpression(entries)
+    )
+  );
+}
+
+// src/visitors/source-injector.ts
+function buildScopeSourceStatement(t, name, loc) {
+  return t.expressionStatement(
+    t.assignmentExpression(
+      "=",
+      t.memberExpression(t.identifier(name), t.identifier("__scopeSource")),
+      t.objectExpression([
+        t.objectProperty(t.identifier("filePath"), t.stringLiteral(loc.filePath)),
+        t.objectProperty(t.identifier("line"), t.numericLiteral(loc.line)),
+        t.objectProperty(t.identifier("column"), t.numericLiteral(loc.column))
+      ])
+    )
+  );
+}
+
+// src/index.ts
+var typeMapsByProgram = /* @__PURE__ */ new WeakMap();
+function scopeBabelPlugin(babel) {
+  const t = babel.types;
+  return {
+    name: "@agent-scope/babel-plugin",
+    visitor: {
+      /**
+       * Pre-collect all top-level type declarations at program entry, before
+       * @babel/plugin-transform-typescript removes them during traversal.
+       *
+       * This fires for the Program node before ANY child visitors, so all
+       * TSInterfaceDeclaration and TSTypeAliasDeclaration nodes are still present.
+       */
+      Program: {
+        enter(path) {
+          const typeMap = /* @__PURE__ */ new Map();
+          for (const stmt of path.node.body) {
+            if (stmt.type === "TSInterfaceDeclaration") {
+              typeMap.set(stmt.id.name, stmt.body.body);
+            }
+            if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "TSInterfaceDeclaration") {
+              typeMap.set(stmt.declaration.id.name, stmt.declaration.body.body);
+            }
+            if (stmt.type === "TSTypeAliasDeclaration" && stmt.typeAnnotation.type === "TSTypeLiteral") {
+              typeMap.set(stmt.id.name, stmt.typeAnnotation.members);
+            }
+            if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "TSTypeAliasDeclaration" && stmt.declaration.typeAnnotation.type === "TSTypeLiteral") {
+              typeMap.set(stmt.declaration.id.name, stmt.declaration.typeAnnotation.members);
+            }
+          }
+          typeMapsByProgram.set(path.node, typeMap);
+        }
+      },
+      FunctionDeclaration(path, state) {
+        if (path.parentPath?.isExportDefaultDeclaration()) return;
+        const component = detectFunctionDeclaration(path.node);
+        if (!component) return;
+        const filePath = resolveFilePath(state);
+        const typeMap = getTypeMap(path);
+        const sourceStmt = buildScopeSourceStatement(t, component.name, {
+          filePath,
+          line: component.line,
+          column: component.column
+        });
+        const scopeProps = safeExtractScopeProps(path.node, typeMap);
+        if (scopeProps) {
+          const propsStmt = buildScopePropsStatement(t, component.name, scopeProps);
+          path.insertAfter(propsStmt);
+          path.insertAfter(sourceStmt);
+        } else {
+          path.insertAfter(sourceStmt);
+        }
+      },
+      VariableDeclaration(path, state) {
+        const component = detectVariableDeclaration(path.node);
+        if (!component) return;
+        const filePath = resolveFilePath(state);
+        const typeMap = getTypeMap(path);
+        const sourceStmt = buildScopeSourceStatement(t, component.name, {
+          filePath,
+          line: component.line,
+          column: component.column
+        });
+        const scopeProps = safeExtractPropsFromVariableDecl(path.node, typeMap);
+        if (scopeProps) {
+          const propsStmt = buildScopePropsStatement(t, component.name, scopeProps);
+          path.insertAfter(propsStmt);
+          path.insertAfter(sourceStmt);
+        } else {
+          path.insertAfter(sourceStmt);
+        }
+      },
+      ExportDefaultDeclaration(path, state) {
+        const decl = path.node.declaration;
+        if (decl.type === "FunctionDeclaration" && decl.id && decl.body) {
+          const component = detectFunctionDeclaration(decl);
+          if (!component) return;
+          const filePath = resolveFilePath(state);
+          const typeMap = getTypeMap(path);
+          const sourceStmt = buildScopeSourceStatement(t, component.name, {
+            filePath,
+            line: component.line,
+            column: component.column
+          });
+          const scopeProps = safeExtractScopeProps(decl, typeMap);
+          if (scopeProps) {
+            const propsStmt = buildScopePropsStatement(t, component.name, scopeProps);
+            path.insertAfter(propsStmt);
+            path.insertAfter(sourceStmt);
+          } else {
+            path.insertAfter(sourceStmt);
+          }
+          return;
+        }
+        if (decl.type === "ArrowFunctionExpression" || decl.type === "FunctionDeclaration" && !decl.id) {
+          if (!checkAnonymousReturnsJSX(decl)) return;
+          const tempName = "_ScopeDefaultExport";
+          const filePath = resolveFilePath(state);
+          const loc = decl.loc?.start ?? { line: 0, column: 0 };
+          const typeMap = getTypeMap(path);
+          const sourceStmt = buildScopeSourceStatement(t, tempName, {
+            filePath,
+            line: loc.line,
+            column: loc.column
+          });
+          const scopeProps = safeExtractScopeProps(
+            decl,
+            typeMap
+          );
+          const replacements = [
+            t.variableDeclaration("const", [
+              t.variableDeclarator(t.identifier(tempName), decl)
+            ]),
+            sourceStmt
+          ];
+          if (scopeProps) {
+            replacements.push(buildScopePropsStatement(t, tempName, scopeProps));
+          }
+          replacements.push(t.exportDefaultDeclaration(t.identifier(tempName)));
+          path.replaceWithMultiple(replacements);
+        }
+      }
+    }
+  };
+}
+function resolveFilePath(state) {
+  return state.opts.filePath ?? state.filename ?? "<unknown>";
+}
+function getTypeMap(path) {
+  const program = path.findParent((p) => p.isProgram());
+  if (!program || !program.isProgram()) return /* @__PURE__ */ new Map();
+  return typeMapsByProgram.get(program.node) ?? /* @__PURE__ */ new Map();
+}
+function safeExtractScopeProps(node, typeMap) {
+  try {
+    return extractScopePropsWithMap(node, typeMap);
+  } catch {
+    return null;
+  }
+}
+function extractScopePropsWithMap(funcNode, typeMap) {
+  const params = funcNode.params;
+  if (params.length === 0) return null;
+  const firstParam = params[0];
+  if (!firstParam) return null;
+  const defaults = extractDefaultValues(params);
+  let typeAnnotation = null;
+  if (firstParam.type === "Identifier" || firstParam.type === "ObjectPattern") {
+    if (firstParam.typeAnnotation?.type === "TSTypeAnnotation") {
+      typeAnnotation = firstParam.typeAnnotation.typeAnnotation;
+    }
+  } else if (firstParam.type === "AssignmentPattern") {
+    const left = firstParam.left;
+    if (left.type === "Identifier" || left.type === "ObjectPattern") {
+      if (left.typeAnnotation?.type === "TSTypeAnnotation") {
+        typeAnnotation = left.typeAnnotation.typeAnnotation;
+      }
+    }
+  }
+  if (!typeAnnotation) return null;
+  if (typeAnnotation.type === "TSTypeLiteral") {
+    const props = extractPropsFromTypeMembers(typeAnnotation.members, defaults);
+    return Object.keys(props).length > 0 ? props : null;
+  }
+  if (typeAnnotation.type === "TSTypeReference") {
+    const typeName = resolveTypeReferenceName(typeAnnotation);
+    if (!typeName) return null;
+    const members = typeMap.get(typeName);
+    if (!members) return null;
+    const props = extractPropsFromTypeMembers(members, defaults);
+    return Object.keys(props).length > 0 ? props : null;
+  }
+  return null;
+}
+function safeExtractPropsFromVariableDecl(node, typeMap) {
+  try {
+    for (const declarator of node.declarations) {
+      if (declarator.id.type !== "Identifier") continue;
+      if (!declarator.init) continue;
+      const init = declarator.init;
+      if (declarator.id.typeAnnotation?.type === "TSTypeAnnotation") {
+        const tsType = declarator.id.typeAnnotation.typeAnnotation;
+        if (tsType.type === "TSTypeReference") {
+          const typeName = resolveTypeReferenceName(tsType);
+          if (typeName === "React.FC" || typeName === "FC" || typeName === "React.FunctionComponent" || typeName === "FunctionComponent") {
+            const typeParams = tsType.typeParameters;
+            const funcNode2 = extractFuncNode(init);
+            const defaults = funcNode2 ? extractDefaultValues(funcNode2.params) : {};
+            if (typeParams && typeParams.params.length > 0) {
+              const firstTypeArg = typeParams.params[0];
+              if (!firstTypeArg) continue;
+              if (firstTypeArg.type === "TSTypeLiteral") {
+                const props = extractPropsFromTypeMembers(firstTypeArg.members, defaults);
+                if (Object.keys(props).length > 0) return props;
+              } else if (firstTypeArg.type === "TSTypeReference") {
+                const refName = resolveTypeReferenceName(firstTypeArg);
+                if (refName) {
+                  const members = typeMap.get(refName);
+                  if (members) {
+                    const props = extractPropsFromTypeMembers(members, defaults);
+                    if (Object.keys(props).length > 0) return props;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      const funcNode = extractFuncNode(init);
+      if (funcNode) {
+        const props = extractScopePropsWithMap(funcNode, typeMap);
+        if (props) return props;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function extractFuncNode(node) {
+  if (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") {
+    return node;
+  }
+  if (node.type === "CallExpression" && node.arguments.length > 0) {
+    const first = node.arguments[0];
+    if (first !== void 0 && (first.type === "ArrowFunctionExpression" || first.type === "FunctionExpression")) {
+      return first;
+    }
+  }
+  return null;
+}
+function checkAnonymousReturnsJSX(decl) {
+  if (decl.type === "ArrowFunctionExpression") {
+    const body = decl.body;
+    if (body.type !== "BlockStatement") {
+      return body.type === "JSXElement" || body.type === "JSXFragment";
+    }
+    return bodyHasJSXReturn(body);
+  }
+  if (decl.type === "FunctionDeclaration" && decl.body) {
+    return bodyHasJSXReturn(decl.body);
+  }
+  return false;
+}
+function bodyHasJSXReturn(block) {
+  for (const stmt of block.body) {
+    if (stmt.type === "ReturnStatement" && stmt.argument && (stmt.argument.type === "JSXElement" || stmt.argument.type === "JSXFragment")) {
+      return true;
+    }
+  }
+  return false;
+}
+var index_default = scopeBabelPlugin;
+
+exports.default = index_default;
+exports.scopeBabelPlugin = scopeBabelPlugin;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map