Experiments with cross-module parsing

src/__tests__/importsAndExports.test.ts

@@ -0,0 +1,25 @@
+import { parseMachinesFromFile } from "..";
+
+describe("Imports and exports", () => {
+  it("Should pick up an identifier exported from a separate file", () => {
+    const file1 = `
+      import { options } from './options';
+
+      createMachine({}, options);
+    `;
+
+    const optionsFile = `
+      export const options = {
+        actions: {
+          nice: () => {},
+        }
+      }
+    `;
+
+    const result = parseMachinesFromFile(file1, {
+      resolveRequire: () => optionsFile,
+    });
+
+    expect(result.machines[0].ast?.options).toBeTruthy();
+  });
+});

src/identifiers.ts

@@ -45,6 +45,40 @@ export const identifierReferencingVariableDeclaration = <Result>(
   });
 };
 
+/**
+ * Finds a declarator in the same file which corresponds
+ * to an identifier of the name you provide
+ */
+export const findImportWithName = (
+  file: any,
+  name: string,
+): t.VariableDeclarator | null | undefined => {
+  let declarator: t.VariableDeclarator | null | undefined = null;
+
+  traverse(file, {
+    VariableDeclarator(path) {
+      if (t.isIdentifier(path.node.id) && path.node.id.name === name) {
+        declarator = path.node as any;
+      }
+    },
+  });
+
+  return declarator;
+};
+
+export const identifierReferencingImport = <Result>(
+  parser: AnyParser<Result>,
+) => {
+  return createParser({
+    babelMatcher: t.isIdentifier,
+    parseNode: (node, context) => {
+      const variableDeclarator = findImportWithName(context.file, node.name);
+
+      return parser.parse(variableDeclarator?.init, context);
+    },
+  });
+};
+
 export const maybeIdentifierTo = <Result>(parser: AnyParser<Result>) => {
   return unionType([parser, identifierReferencingVariableDeclaration(parser)]);
 };

src/parseMachinesFromFile.ts

@@ -1,12 +1,16 @@
 import * as parser from "@babel/parser";
 import traverse from "@babel/traverse";
 import { MachineConfig } from "xstate";
+import { ParseOptions } from ".";
 import { MachineCallExpression } from "./machineCallExpression";
 import { MachineParseResult } from "./MachineParseResult";
 import { toMachineConfig } from "./toMachineConfig";
 import { ParseResult } from "./types";
 
-export const parseMachinesFromFile = (fileContents: string): ParseResult => {
+export const parseMachinesFromFile = (
+  fileContents: string,
+  options?: ParseOptions,
+): ParseResult => {
   if (
     !fileContents.includes("createMachine") &&
     !fileContents.includes("Machine")
@@ -23,6 +27,7 @@ export const parseMachinesFromFile = (fileContents: string): ParseResult => {
       "jsx",
       ["decorators", { decoratorsBeforeExport: false }],
     ],
+    sourceFilename: options?.sourceFilename,
   });
 
   let result: ParseResult = {
@@ -33,6 +38,7 @@ export const parseMachinesFromFile = (fileContents: string): ParseResult => {
     CallExpression(path: any) {
       const ast = MachineCallExpression.parse(path.node, {
         file: parseResult,
+        resolveRequire: options?.resolveRequire || (() => undefined),
       });
       if (ast) {
         result.machines.push(new MachineParseResult({ ast }));

src/types.ts

@@ -11,6 +11,10 @@ export interface StringLiteralNode {
 
 export interface ParserContext {
   file: t.File;
+  resolveRequire: (
+    sourceFile: string,
+    relativeImport: string,
+  ) => string | undefined;
 }
 
 export interface Parser<T extends t.Node = any, Result = any> {
@@ -26,3 +30,11 @@ export interface AnyParser<Result> {
 export interface ParseResult {
   machines: MachineParseResult[];
 }
+
+export interface ParseOptions {
+  sourceFilename?: string;
+  resolveRequire?: (
+    sourceFile: string,
+    relativeImport: string,
+  ) => string | undefined;
+}