@fragments-sdk/cli 0.11.1 → 0.13.0

package/dist/chunk-EYXVAMEX.js

@@ -0,0 +1,626 @@
+import { createRequire as __banner_createRequire } from 'module'; const require = __banner_createRequire(import.meta.url);
+
+// src/core/component-extractor.ts
+import ts from "typescript";
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+function createComponentExtractor(tsconfigPath) {
+  let projectVersion = 0;
+  const fileVersions = /* @__PURE__ */ new Map();
+  const fileSnapshots = /* @__PURE__ */ new Map();
+  const rootDir = tsconfigPath ? dirname(resolve(tsconfigPath)) : process.cwd();
+  const parsedCommandLine = tsconfigPath ? parseTsConfig(tsconfigPath) : inferCompilerOptions(rootDir);
+  const scriptFileNames = new Set(parsedCommandLine.fileNames);
+  const host = {
+    getProjectVersion: () => projectVersion.toString(),
+    getScriptVersion: (fileName) => (fileVersions.get(fileName) ?? 0).toString(),
+    getScriptSnapshot: (fileName) => {
+      const cached = fileSnapshots.get(fileName);
+      if (cached) return cached;
+      let text;
+      try {
+        text = readFileSync(fileName, "utf-8");
+      } catch {
+        return void 0;
+      }
+      const snapshot = ts.ScriptSnapshot.fromString(text);
+      fileSnapshots.set(fileName, snapshot);
+      return snapshot;
+    },
+    getScriptFileNames: () => [...scriptFileNames],
+    getCompilationSettings: () => parsedCommandLine.options,
+    getCurrentDirectory: () => rootDir,
+    getDefaultLibFileName: ts.getDefaultLibFilePath,
+    fileExists: ts.sys.fileExists,
+    readFile: ts.sys.readFile,
+    readDirectory: ts.sys.readDirectory,
+    directoryExists: ts.sys.directoryExists,
+    getDirectories: ts.sys.getDirectories
+  };
+  const languageService = ts.createLanguageService(host, ts.createDocumentRegistry());
+  function ensureFile(filePath) {
+    const resolved = resolve(filePath);
+    if (!scriptFileNames.has(resolved)) {
+      scriptFileNames.add(resolved);
+      projectVersion++;
+    }
+  }
+  function getChecker() {
+    const program = languageService.getProgram();
+    if (!program) throw new Error("Failed to get program from LanguageService");
+    return program.getTypeChecker();
+  }
+  function getSourceFile(filePath) {
+    return languageService.getProgram()?.getSourceFile(resolve(filePath));
+  }
+  return {
+    extract(filePath, exportName) {
+      const resolved = resolve(filePath);
+      ensureFile(resolved);
+      const sourceFile = getSourceFile(resolved);
+      if (!sourceFile) return null;
+      const checker = getChecker();
+      const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return null;
+      const exports = checker.getExportsOfModule(moduleSymbol);
+      const targetName = exportName ?? findPrimaryExport(exports, sourceFile);
+      if (!targetName) return null;
+      const exportSymbol = exports.find((s) => s.getName() === targetName);
+      if (!exportSymbol) return null;
+      const component = resolveExportedComponent(checker, exportSymbol, sourceFile);
+      if (!component) return null;
+      return buildComponentMeta(checker, component, resolved, sourceFile, exports);
+    },
+    extractAll(filePath) {
+      const resolved = resolve(filePath);
+      ensureFile(resolved);
+      const sourceFile = getSourceFile(resolved);
+      if (!sourceFile) return [];
+      const checker = getChecker();
+      const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return [];
+      const exports = checker.getExportsOfModule(moduleSymbol);
+      const results = [];
+      for (const exportSymbol of exports) {
+        const name = exportSymbol.getName();
+        if (!/^[A-Z]/.test(name)) continue;
+        const component = resolveExportedComponent(checker, exportSymbol, sourceFile);
+        if (!component) continue;
+        const meta = buildComponentMeta(checker, component, resolved, sourceFile, exports);
+        if (meta) results.push(meta);
+      }
+      return results;
+    },
+    invalidate(filePath) {
+      const resolved = resolve(filePath);
+      fileVersions.set(resolved, (fileVersions.get(resolved) ?? 0) + 1);
+      fileSnapshots.delete(resolved);
+      projectVersion++;
+    },
+    dispose() {
+      languageService.dispose();
+      fileSnapshots.clear();
+      fileVersions.clear();
+    }
+  };
+}
+function parseTsConfig(tsconfigPath) {
+  const resolved = resolve(tsconfigPath);
+  const configFile = ts.readConfigFile(resolved, ts.sys.readFile);
+  if (configFile.error) {
+    throw new Error(`Failed to read tsconfig: ${ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n")}`);
+  }
+  return ts.parseJsonConfigFileContent(
+    configFile.config,
+    ts.sys,
+    dirname(resolved),
+    void 0,
+    resolved
+  );
+}
+function inferCompilerOptions(rootDir) {
+  return {
+    options: {
+      target: ts.ScriptTarget.ES2022,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Bundler,
+      jsx: ts.JsxEmit.ReactJSX,
+      allowSyntheticDefaultImports: true,
+      esModuleInterop: true,
+      skipLibCheck: true,
+      strict: false,
+      noEmit: true
+    },
+    fileNames: [],
+    errors: []
+  };
+}
+function findPrimaryExport(exports, sourceFile) {
+  const defaultExport = exports.find((s) => s.getName() === "default");
+  if (defaultExport) return "default";
+  for (const s of exports) {
+    if (/^[A-Z][a-zA-Z0-9]*$/.test(s.getName())) {
+      return s.getName();
+    }
+  }
+  return null;
+}
+function resolveExportedComponent(checker, exportSymbol, sourceFile) {
+  const name = exportSymbol.getName();
+  let symbol = exportSymbol;
+  if (symbol.flags & ts.SymbolFlags.Alias) {
+    symbol = checker.getAliasedSymbol(symbol);
+  }
+  const declarations = symbol.getDeclarations();
+  if (!declarations || declarations.length === 0) return null;
+  const declaration = declarations[0];
+  if (ts.isVariableDeclaration(declaration) && declaration.initializer) {
+    return resolveFromExpression(checker, name, declaration.initializer, declaration, sourceFile);
+  }
+  if (ts.isFunctionDeclaration(declaration)) {
+    const propsType = extractPropsFromFunctionLike(checker, declaration);
+    return propsType ? { name, propsType, componentNode: declaration, compoundParts: null } : null;
+  }
+  if (ts.isExportAssignment(declaration) && declaration.expression) {
+    return resolveFromExpression(checker, name, declaration.expression, null, sourceFile);
+  }
+  return null;
+}
+function resolveFromExpression(checker, name, expression, variableDecl, sourceFile) {
+  expression = unwrapExpression(expression);
+  if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) {
+    const propsType = extractPropsFromFunctionLike(checker, expression);
+    return propsType ? { name, propsType, componentNode: expression, compoundParts: null } : null;
+  }
+  if (ts.isCallExpression(expression)) {
+    return resolveCallExpression(checker, name, expression, variableDecl, sourceFile);
+  }
+  if (ts.isIdentifier(expression)) {
+    const sym = checker.getSymbolAtLocation(expression);
+    if (sym) {
+      const decls = sym.getDeclarations();
+      if (decls && decls.length > 0) {
+        const decl = decls[0];
+        if (ts.isVariableDeclaration(decl) && decl.initializer) {
+          return resolveFromExpression(checker, name, decl.initializer, decl, sourceFile);
+        }
+        if (ts.isFunctionDeclaration(decl)) {
+          const propsType = extractPropsFromFunctionLike(checker, decl);
+          return propsType ? { name, propsType, componentNode: decl, compoundParts: null } : null;
+        }
+      }
+    }
+  }
+  if (variableDecl?.type && ts.isTypeReferenceNode(variableDecl.type)) {
+    const typeName = variableDecl.type.typeName.getText(sourceFile);
+    if (typeName.includes("FC") || typeName.includes("FunctionComponent")) {
+      const typeArg = variableDecl.type.typeArguments?.[0];
+      if (typeArg) {
+        const propsType = checker.getTypeFromTypeNode(typeArg);
+        return { name, propsType, componentNode: expression, compoundParts: null };
+      }
+    }
+  }
+  return null;
+}
+function resolveCallExpression(checker, name, call, variableDecl, sourceFile) {
+  const callee = call.expression;
+  if (isObjectAssignCall(callee, sourceFile)) {
+    return resolveObjectAssign(checker, name, call, sourceFile);
+  }
+  if (isForwardRefCall(callee)) {
+    return resolveForwardRef(checker, name, call, sourceFile);
+  }
+  if (isMemoCall(callee)) {
+    const innerArg = call.arguments[0];
+    if (innerArg) {
+      return resolveFromExpression(checker, name, innerArg, variableDecl, sourceFile);
+    }
+  }
+  return null;
+}
+function resolveObjectAssign(checker, name, call, sourceFile) {
+  if (call.arguments.length < 2) return null;
+  const rootExpr = call.arguments[0];
+  const rootResult = resolveFromExpression(checker, name, rootExpr, null, sourceFile);
+  const subsArg = call.arguments[1];
+  const compoundParts = /* @__PURE__ */ new Map();
+  if (ts.isObjectLiteralExpression(subsArg)) {
+    for (const prop of subsArg.properties) {
+      let subName = null;
+      let subExpression = null;
+      if (ts.isShorthandPropertyAssignment(prop)) {
+        subName = prop.name.text;
+        const sym = checker.getSymbolAtLocation(prop.name);
+        if (sym) {
+          const subPropsType = extractPropsFromComponentSymbol(checker, sym);
+          if (subPropsType) {
+            compoundParts.set(subName, subPropsType);
+          }
+        }
+      } else if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+        subName = prop.name.text;
+        subExpression = prop.initializer;
+        if (subExpression) {
+          const subType = extractPropsFromExpression(checker, subExpression, sourceFile);
+          if (subType) {
+            compoundParts.set(subName, subType);
+          }
+        }
+      }
+    }
+  }
+  return {
+    name,
+    propsType: rootResult?.propsType ?? null,
+    componentNode: rootResult?.componentNode ?? rootExpr,
+    compoundParts: compoundParts.size > 0 ? compoundParts : null
+  };
+}
+function extractPropsFromComponentSymbol(checker, symbol) {
+  let sym = symbol;
+  if (sym.flags & ts.SymbolFlags.Alias) {
+    sym = checker.getAliasedSymbol(sym);
+  }
+  const decls = sym.getDeclarations();
+  if (!decls || decls.length === 0) return null;
+  const decl = decls[0];
+  if (ts.isFunctionDeclaration(decl)) {
+    return extractPropsFromFunctionLike(checker, decl);
+  }
+  if (ts.isVariableDeclaration(decl) && decl.initializer) {
+    return extractPropsFromExpressionDeep(checker, decl);
+  }
+  return null;
+}
+function extractPropsFromExpression(checker, expr, sourceFile) {
+  expr = unwrapExpression(expr);
+  if (ts.isIdentifier(expr)) {
+    const sym = checker.getSymbolAtLocation(expr);
+    if (sym) return extractPropsFromComponentSymbol(checker, sym);
+  }
+  if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) {
+    return extractPropsFromFunctionLike(checker, expr);
+  }
+  if (ts.isCallExpression(expr)) {
+    if (isForwardRefCall(expr.expression)) {
+      const typeArg = expr.typeArguments?.[1];
+      if (typeArg) return checker.getTypeFromTypeNode(typeArg);
+      const innerArg = expr.arguments[0];
+      if (innerArg && (ts.isArrowFunction(innerArg) || ts.isFunctionExpression(innerArg))) {
+        return extractPropsFromFunctionLike(checker, innerArg);
+      }
+    }
+    if (isMemoCall(expr.expression) && expr.arguments[0]) {
+      return extractPropsFromExpression(checker, expr.arguments[0], sourceFile);
+    }
+  }
+  return null;
+}
+function extractPropsFromExpressionDeep(checker, decl) {
+  if (!decl.initializer) return null;
+  const expr = unwrapExpression(decl.initializer);
+  if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) {
+    return extractPropsFromFunctionLike(checker, expr);
+  }
+  if (ts.isCallExpression(expr)) {
+    if (isForwardRefCall(expr.expression)) {
+      const typeArg = expr.typeArguments?.[1];
+      if (typeArg) return checker.getTypeFromTypeNode(typeArg);
+      const innerArg = expr.arguments[0];
+      if (innerArg && (ts.isArrowFunction(innerArg) || ts.isFunctionExpression(innerArg))) {
+        return extractPropsFromFunctionLike(checker, innerArg);
+      }
+    }
+    if (isMemoCall(expr.expression) && expr.arguments[0]) {
+      return extractPropsFromExpressionDeep(checker, {
+        ...decl,
+        initializer: expr.arguments[0]
+      });
+    }
+  }
+  return null;
+}
+function resolveForwardRef(checker, name, call, sourceFile) {
+  const propsTypeArg = call.typeArguments?.[1];
+  if (propsTypeArg) {
+    const propsType = checker.getTypeFromTypeNode(propsTypeArg);
+    const innerArg2 = call.arguments[0];
+    const componentNode = innerArg2 && (ts.isArrowFunction(innerArg2) || ts.isFunctionExpression(innerArg2)) ? innerArg2 : null;
+    return { name, propsType, componentNode, compoundParts: null };
+  }
+  const innerArg = call.arguments[0];
+  if (innerArg) {
+    if (ts.isArrowFunction(innerArg) || ts.isFunctionExpression(innerArg)) {
+      const propsType = extractPropsFromFunctionLike(checker, innerArg);
+      return propsType ? { name, propsType, componentNode: innerArg, compoundParts: null } : null;
+    }
+    if (ts.isIdentifier(innerArg)) {
+      const sym = checker.getSymbolAtLocation(innerArg);
+      if (sym) {
+        const propsType = extractPropsFromComponentSymbol(checker, sym);
+        if (propsType) return { name, propsType, componentNode: innerArg, compoundParts: null };
+      }
+    }
+  }
+  return null;
+}
+function extractPropsFromFunctionLike(checker, func) {
+  const firstParam = func.parameters[0];
+  if (!firstParam) return null;
+  if (firstParam.type) {
+    return checker.getTypeFromTypeNode(firstParam.type);
+  }
+  const paramSymbol = checker.getSymbolAtLocation(firstParam.name);
+  if (paramSymbol) {
+    return checker.getTypeOfSymbolAtLocation(paramSymbol, firstParam);
+  }
+  return null;
+}
+function buildComponentMeta(checker, component, filePath, sourceFile, moduleExports) {
+  const props = {};
+  const sourceFilePath = toPosixPath(sourceFile.fileName);
+  if (component.propsType) {
+    extractPropsFromType(checker, component.propsType, props, sourceFilePath);
+  }
+  const defaults = component.componentNode ? extractDefaultValues(component.componentNode) : {};
+  for (const [propName, defaultVal] of Object.entries(defaults)) {
+    if (props[propName]) {
+      props[propName].default = defaultVal;
+    }
+  }
+  let composition = null;
+  if (component.compoundParts && component.compoundParts.size > 0) {
+    const parts = [];
+    for (const [partName, partType] of component.compoundParts) {
+      const partProps = {};
+      extractPropsFromType(checker, partType, partProps, sourceFilePath);
+      parts.push({ name: partName, props: partProps });
+    }
+    composition = {
+      pattern: "compound",
+      parts,
+      required: []
+      // Could be inferred from usage patterns
+    };
+  }
+  let description = "";
+  const componentSymbol = moduleExports.find((s) => s.getName() === component.name);
+  if (componentSymbol) {
+    description = extractJSDocDescription(checker, componentSymbol);
+  }
+  const exportNames = moduleExports.filter((s) => /^[A-Z]/.test(s.getName())).map((s) => s.getName());
+  const dependencies = extractDependencies(sourceFile);
+  return {
+    name: component.name,
+    filePath,
+    description,
+    props,
+    composition,
+    exports: exportNames,
+    dependencies
+  };
+}
+function extractPropsFromType(checker, propsType, result, sourceFilePath) {
+  for (const symbol of checker.getPropertiesOfType(propsType)) {
+    const propName = symbol.getName();
+    if (propName.startsWith("_") || propName.startsWith("$")) continue;
+    if (propName === "key" || propName === "ref") continue;
+    const declarations = symbol.getDeclarations() ?? [];
+    const isLocal = declarations.some(
+      (d) => toPosixPath(d.getSourceFile().fileName) === sourceFilePath
+    );
+    const referenceNode = declarations[0];
+    if (!referenceNode) continue;
+    const propType = checker.getTypeOfSymbolAtLocation(symbol, referenceNode);
+    const serialized = serializePropType(checker, propType);
+    const description = ts.displayPartsToString(symbol.getDocumentationComment(checker)).trim();
+    const required = (symbol.flags & ts.SymbolFlags.Optional) === 0;
+    let jsDocDefault;
+    const jsDocTags = symbol.getJsDocTags(checker);
+    const defaultTag = jsDocTags.find((t) => t.name === "default");
+    if (defaultTag?.text) {
+      jsDocDefault = ts.displayPartsToString(defaultTag.text).trim();
+    }
+    result[propName] = {
+      name: propName,
+      type: serialized.type,
+      typeKind: serialized.typeKind,
+      values: serialized.values,
+      default: jsDocDefault,
+      description: description || void 0,
+      required,
+      source: isLocal ? "local" : "inherited"
+    };
+  }
+}
+function serializePropType(checker, type) {
+  const aliasSymbol = type.aliasSymbol;
+  if (aliasSymbol) {
+    const aliasName = aliasSymbol.getName();
+    if (aliasName === "ReactNode") {
+      return { type: "ReactNode", typeKind: "node" };
+    }
+    if (aliasName === "ReactElement") {
+      return { type: "ReactElement", typeKind: "element" };
+    }
+  }
+  if (type.isUnion()) {
+    const nonNullableTypes = type.types.filter(
+      (t) => !(t.flags & ts.TypeFlags.Undefined || t.flags & ts.TypeFlags.Null || t.flags & ts.TypeFlags.Void)
+    );
+    if (nonNullableTypes.length === 1) {
+      return serializePropType(checker, nonNullableTypes[0]);
+    }
+    if (nonNullableTypes.length > 0 && nonNullableTypes.every((t) => t.isStringLiteral())) {
+      const values = nonNullableTypes.map((t) => t.value);
+      return {
+        type: values.map((v) => `"${v}"`).join(" | "),
+        typeKind: "enum",
+        values
+      };
+    }
+    if (nonNullableTypes.every((t) => isBooleanLike(t))) {
+      return { type: "boolean", typeKind: "boolean" };
+    }
+    const typeStr2 = checker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
+    return { type: typeStr2, typeKind: "union" };
+  }
+  const typeStr = checker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
+  if (typeStr.includes("ReactNode")) {
+    return { type: "ReactNode", typeKind: "node" };
+  }
+  if (typeStr.includes("ReactElement") || typeStr.includes("JSX.Element")) {
+    return { type: "ReactElement", typeKind: "element" };
+  }
+  if (type.getCallSignatures().length > 0) {
+    return { type: typeStr, typeKind: "function" };
+  }
+  if (type.flags & ts.TypeFlags.String) return { type: "string", typeKind: "string" };
+  if (type.flags & ts.TypeFlags.Number) return { type: "number", typeKind: "number" };
+  if (type.flags & ts.TypeFlags.Boolean || type.flags & ts.TypeFlags.BooleanLiteral) {
+    return { type: "boolean", typeKind: "boolean" };
+  }
+  if (type.isStringLiteral()) {
+    return { type: `"${type.value}"`, typeKind: "enum", values: [type.value] };
+  }
+  if (checker.isArrayType(type) || checker.isTupleType(type)) {
+    return { type: typeStr, typeKind: "array" };
+  }
+  if (type.flags & ts.TypeFlags.Object) {
+    return { type: typeStr, typeKind: "object" };
+  }
+  return { type: typeStr, typeKind: "custom" };
+}
+function extractDefaultValues(node) {
+  const defaults = {};
+  let funcNode = null;
+  if (ts.isFunctionDeclaration(node) || ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    funcNode = node;
+  }
+  if (!funcNode?.parameters?.length) return defaults;
+  const firstParam = funcNode.parameters[0];
+  if (!ts.isObjectBindingPattern(firstParam.name)) return defaults;
+  for (const element of firstParam.name.elements) {
+    let propName = null;
+    if (element.propertyName) {
+      if (ts.isIdentifier(element.propertyName) || ts.isStringLiteral(element.propertyName)) {
+        propName = element.propertyName.text;
+      }
+    } else if (ts.isIdentifier(element.name)) {
+      propName = element.name.text;
+    }
+    if (!propName || !element.initializer) continue;
+    const value = readLiteralValue(element.initializer);
+    if (value !== void 0) {
+      defaults[propName] = value;
+    }
+  }
+  return defaults;
+}
+function readLiteralValue(expression) {
+  if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  if (ts.isNumericLiteral(expression)) {
+    return expression.text;
+  }
+  if (expression.kind === ts.SyntaxKind.TrueKeyword) return "true";
+  if (expression.kind === ts.SyntaxKind.FalseKeyword) return "false";
+  if (expression.kind === ts.SyntaxKind.NullKeyword) return "null";
+  if (ts.isPrefixUnaryExpression(expression) && expression.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(expression.operand)) {
+    return `-${expression.operand.text}`;
+  }
+  return void 0;
+}
+function extractJSDocDescription(checker, symbol) {
+  let sym = symbol;
+  if (sym.flags & ts.SymbolFlags.Alias) {
+    sym = checker.getAliasedSymbol(sym);
+  }
+  const docComment = ts.displayPartsToString(sym.getDocumentationComment(checker)).trim();
+  if (docComment) return docComment;
+  const decls = sym.getDeclarations();
+  if (decls) {
+    for (const decl of decls) {
+      const sourceFile = decl.getSourceFile();
+      for (const stmt of sourceFile.statements) {
+        if ((ts.isInterfaceDeclaration(stmt) || ts.isTypeAliasDeclaration(stmt)) && stmt.name.text === `${symbol.getName()}Props`) {
+          const propsDoc = ts.displayPartsToString(
+            checker.getSymbolAtLocation(stmt.name)?.getDocumentationComment(checker) ?? []
+          ).trim();
+          if (propsDoc) return propsDoc;
+        }
+      }
+    }
+  }
+  return "";
+}
+function extractDependencies(sourceFile) {
+  const deps = [];
+  for (const stmt of sourceFile.statements) {
+    if (!ts.isImportDeclaration(stmt)) continue;
+    if (!ts.isStringLiteral(stmt.moduleSpecifier)) continue;
+    const modulePath = stmt.moduleSpecifier.text;
+    if (!modulePath.startsWith(".") && !modulePath.startsWith("/")) continue;
+    const clause = stmt.importClause;
+    if (!clause) continue;
+    if (clause.name && /^[A-Z]/.test(clause.name.text)) {
+      deps.push(clause.name.text);
+    }
+    if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) {
+      for (const element of clause.namedBindings.elements) {
+        if (/^[A-Z]/.test(element.name.text)) {
+          deps.push(element.name.text);
+        }
+      }
+    }
+  }
+  return deps;
+}
+function unwrapExpression(expr) {
+  while (true) {
+    if (ts.isParenthesizedExpression(expr)) {
+      expr = expr.expression;
+    } else if (ts.isAsExpression(expr) || ts.isTypeAssertionExpression(expr)) {
+      expr = expr.expression;
+    } else {
+      return expr;
+    }
+  }
+}
+function isObjectAssignCall(callee, sourceFile) {
+  if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === "Object" && callee.name.text === "assign") {
+    return true;
+  }
+  return false;
+}
+function isForwardRefCall(callee) {
+  if (ts.isPropertyAccessExpression(callee) && callee.name.text === "forwardRef") {
+    return true;
+  }
+  if (ts.isIdentifier(callee) && callee.text === "forwardRef") {
+    return true;
+  }
+  return false;
+}
+function isMemoCall(callee) {
+  if (ts.isPropertyAccessExpression(callee) && callee.name.text === "memo") {
+    return true;
+  }
+  if (ts.isIdentifier(callee) && callee.text === "memo") {
+    return true;
+  }
+  return false;
+}
+function isBooleanLike(type) {
+  return (type.flags & ts.TypeFlags.BooleanLike) !== 0 || type.flags === ts.TypeFlags.BooleanLiteral;
+}
+function toPosixPath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+
+export {
+  createComponentExtractor
+};
+//# sourceMappingURL=chunk-EYXVAMEX.js.map