@nudojs/parser 0.1.0

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@nudojs/parser",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@nudojs/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts"
+  }
+}

package/src/__tests__/directives-phase2.test.ts

@@ -0,0 +1,113 @@
+import { describe, it, expect } from "vitest";
+import { parse } from "../parse.ts";
+import { extractDirectives, parseTypeValueExpr } from "../directives.ts";
+import { T, typeValueEquals, typeValueToString } from "@nudojs/core";
+
+describe("parseTypeValueExpr: Phase 2 enhancements", () => {
+  it("parses T.array(T.number)", () => {
+    const result = parseTypeValueExpr("T.array(T.number)");
+    expect(result.kind).toBe("array");
+    if (result.kind === "array") {
+      expect(typeValueEquals(result.element, T.number)).toBe(true);
+    }
+  });
+
+  it("parses T.tuple([T.number, T.string])", () => {
+    const result = parseTypeValueExpr("T.tuple([T.number, T.string])");
+    expect(result.kind).toBe("tuple");
+    if (result.kind === "tuple") {
+      expect(result.elements).toHaveLength(2);
+      expect(typeValueEquals(result.elements[0], T.number)).toBe(true);
+      expect(typeValueEquals(result.elements[1], T.string)).toBe(true);
+    }
+  });
+
+  it("parses T.object({ x: T.number, y: T.string })", () => {
+    const result = parseTypeValueExpr("T.object({ x: T.number, y: T.string })");
+    expect(result.kind).toBe("object");
+    if (result.kind === "object") {
+      expect(typeValueEquals(result.properties.x, T.number)).toBe(true);
+      expect(typeValueEquals(result.properties.y, T.string)).toBe(true);
+    }
+  });
+
+  it("parses nested T.object with T.array", () => {
+    const result = parseTypeValueExpr("T.object({ items: T.array(T.number) })");
+    expect(result.kind).toBe("object");
+    if (result.kind === "object") {
+      expect(result.properties.items.kind).toBe("array");
+    }
+  });
+
+  it("parses T.object({})", () => {
+    const result = parseTypeValueExpr("T.object({})");
+    expect(result.kind).toBe("object");
+    if (result.kind === "object") {
+      expect(Object.keys(result.properties)).toHaveLength(0);
+    }
+  });
+
+  it("parses T.tuple([])", () => {
+    const result = parseTypeValueExpr("T.tuple([])");
+    expect(result.kind).toBe("tuple");
+    if (result.kind === "tuple") {
+      expect(result.elements).toHaveLength(0);
+    }
+  });
+});
+
+describe("extractDirectives: @nudo:mock", () => {
+  it("extracts inline mock directive", () => {
+    const source = `
+/**
+ * @nudo:mock fetch = T.unknown
+ * @nudo:case "test" (1)
+ */
+function foo(x) { return x; }
+`;
+    const ast = parse(source);
+    const results = extractDirectives(ast);
+    expect(results).toHaveLength(1);
+    const mocks = results[0].directives.filter((d) => d.kind === "mock");
+    expect(mocks).toHaveLength(1);
+    expect(mocks[0].kind).toBe("mock");
+    if (mocks[0].kind === "mock") {
+      expect(mocks[0].name).toBe("fetch");
+      expect(mocks[0].expression).toBe("T.unknown");
+    }
+  });
+
+  it("extracts mock from file directive", () => {
+    const source = `
+/**
+ * @nudo:mock utils from "./utils.mock.js"
+ * @nudo:case "test" (1)
+ */
+function foo(x) { return x; }
+`;
+    const ast = parse(source);
+    const results = extractDirectives(ast);
+    const mocks = results[0].directives.filter((d) => d.kind === "mock");
+    expect(mocks).toHaveLength(1);
+    if (mocks[0].kind === "mock") {
+      expect(mocks[0].name).toBe("utils");
+      expect(mocks[0].fromPath).toBe("./utils.mock.js");
+    }
+  });
+
+  it("extracts both mock and case directives", () => {
+    const source = `
+/**
+ * @nudo:mock helper = T.number
+ * @nudo:case "test" (T.number)
+ */
+function foo(x) { return x; }
+`;
+    const ast = parse(source);
+    const results = extractDirectives(ast);
+    const mocks = results[0].directives.filter((d) => d.kind === "mock");
+    const cases = results[0].directives.filter((d) => d.kind === "case");
+    expect(mocks).toHaveLength(1);
+    expect(cases).toHaveLength(1);
+  });
+});

package/src/__tests__/directives-phase3.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, expect } from "vitest";
+import { T } from "@nudojs/core";
+import { extractDirectives } from "../directives.ts";
+import { parse } from "../parse.ts";
+
+function getDirectives(source: string) {
+  const ast = parse(source);
+  return extractDirectives(ast);
+}
+
+describe("@nudo:pure directive", () => {
+  it("parses @nudo:pure", () => {
+    const fns = getDirectives(`
+      /**
+       * @nudo:pure
+       * @nudo:case "test" (1, 2)
+       */
+      function add(a, b) { return a + b; }
+    `);
+    expect(fns.length).toBe(1);
+    const directives = fns[0].directives;
+    expect(directives.some((d) => d.kind === "pure")).toBe(true);
+    expect(directives.some((d) => d.kind === "case")).toBe(true);
+  });
+});
+
+describe("@nudo:skip directive", () => {
+  it("parses @nudo:skip without return type", () => {
+    const fns = getDirectives(`
+      /**
+       * @nudo:skip
+       */
+      function external() {}
+    `);
+    expect(fns.length).toBe(1);
+    const skip = fns[0].directives.find((d) => d.kind === "skip");
+    expect(skip).toBeDefined();
+    if (skip && skip.kind === "skip") {
+      expect(skip.returns).toBeUndefined();
+    }
+  });
+
+  it("parses @nudo:skip with return type", () => {
+    const fns = getDirectives(`
+      /**
+       * @nudo:skip T.number
+       */
+      function external() {}
+    `);
+    expect(fns.length).toBe(1);
+    const skip = fns[0].directives.find((d) => d.kind === "skip");
+    expect(skip).toBeDefined();
+    if (skip && skip.kind === "skip") {
+      expect(skip.returns).toEqual(T.number);
+    }
+  });
+});
+
+describe("@nudo:sample directive", () => {
+  it("parses @nudo:sample with count", () => {
+    const fns = getDirectives(`
+      /**
+       * @nudo:sample 5
+       * @nudo:case "test" (T.number)
+       */
+      function loop(n) { return n; }
+    `);
+    expect(fns.length).toBe(1);
+    const sample = fns[0].directives.find((d) => d.kind === "sample");
+    expect(sample).toBeDefined();
+    if (sample && sample.kind === "sample") {
+      expect(sample.count).toBe(5);
+    }
+  });
+});
+
+describe("@nudo:returns directive", () => {
+  it("parses @nudo:returns with type", () => {
+    const fns = getDirectives(`
+      /**
+       * @nudo:returns (T.number)
+       * @nudo:case "test" (1, 2)
+       */
+      function add(a, b) { return a + b; }
+    `);
+    expect(fns.length).toBe(1);
+    const returns = fns[0].directives.find((d) => d.kind === "returns");
+    expect(returns).toBeDefined();
+    if (returns && returns.kind === "returns") {
+      expect(returns.expected).toEqual(T.number);
+    }
+  });
+});

package/src/__tests__/directives.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect } from "vitest";
+import { parse } from "../parse.ts";
+import { extractDirectives, parseTypeValueExpr } from "../directives.ts";
+import { T, typeValueEquals } from "@nudojs/core";
+
+describe("parseTypeValueExpr", () => {
+  it("parses T.number", () => {
+    expect(typeValueEquals(parseTypeValueExpr("T.number"), T.number)).toBe(true);
+  });
+
+  it("parses T.string", () => {
+    expect(typeValueEquals(parseTypeValueExpr("T.string"), T.string)).toBe(true);
+  });
+
+  it("parses T.boolean", () => {
+    expect(typeValueEquals(parseTypeValueExpr("T.boolean"), T.boolean)).toBe(true);
+  });
+
+  it("parses numeric literals", () => {
+    expect(typeValueEquals(parseTypeValueExpr("42"), T.literal(42))).toBe(true);
+    expect(typeValueEquals(parseTypeValueExpr("-3"), T.literal(-3))).toBe(true);
+    expect(typeValueEquals(parseTypeValueExpr("1.5"), T.literal(1.5))).toBe(true);
+  });
+
+  it("parses string literals", () => {
+    expect(typeValueEquals(parseTypeValueExpr('"hello"'), T.literal("hello"))).toBe(true);
+    expect(typeValueEquals(parseTypeValueExpr("'world'"), T.literal("world"))).toBe(true);
+  });
+
+  it("parses boolean literals", () => {
+    expect(typeValueEquals(parseTypeValueExpr("true"), T.literal(true))).toBe(true);
+    expect(typeValueEquals(parseTypeValueExpr("false"), T.literal(false))).toBe(true);
+  });
+
+  it("parses null and undefined", () => {
+    expect(typeValueEquals(parseTypeValueExpr("null"), T.literal(null))).toBe(true);
+    expect(typeValueEquals(parseTypeValueExpr("undefined"), T.literal(undefined))).toBe(true);
+  });
+
+  it("parses T.literal(...)", () => {
+    expect(typeValueEquals(parseTypeValueExpr("T.literal(42)"), T.literal(42))).toBe(true);
+    expect(typeValueEquals(parseTypeValueExpr('T.literal("hi")'), T.literal("hi"))).toBe(true);
+  });
+
+  it("parses T.union(...)", () => {
+    const result = parseTypeValueExpr("T.union(T.number, T.string)");
+    const expected = T.union(T.number, T.string);
+    expect(typeValueEquals(result, expected)).toBe(true);
+  });
+});
+
+describe("extractDirectives", () => {
+  it("extracts @nudo:case directives from function", () => {
+    const source = `
+/**
+ * @nudo:case "concrete" (1, 2)
+ * @nudo:case "symbolic" (T.number, T.number)
+ */
+function calc(a, b) {
+  return a + b;
+}
+`;
+    const ast = parse(source);
+    const results = extractDirectives(ast);
+    expect(results).toHaveLength(1);
+    expect(results[0].name).toBe("calc");
+    expect(results[0].directives).toHaveLength(2);
+
+    const d0 = results[0].directives[0];
+    expect(d0.kind).toBe("case");
+    expect(d0.name).toBe("concrete");
+    expect(d0.args).toHaveLength(2);
+    expect(typeValueEquals(d0.args[0], T.literal(1))).toBe(true);
+    expect(typeValueEquals(d0.args[1], T.literal(2))).toBe(true);
+
+    const d1 = results[0].directives[1];
+    expect(d1.name).toBe("symbolic");
+    expect(typeValueEquals(d1.args[0], T.number)).toBe(true);
+    expect(typeValueEquals(d1.args[1], T.number)).toBe(true);
+  });
+
+  it("extracts from multiple functions", () => {
+    const source = `
+/**
+ * @nudo:case "test" (1)
+ */
+function foo(x) { return x; }
+
+/**
+ * @nudo:case "test2" ("hello")
+ */
+function bar(s) { return s; }
+`;
+    const ast = parse(source);
+    const results = extractDirectives(ast);
+    expect(results).toHaveLength(2);
+    expect(results[0].name).toBe("foo");
+    expect(results[1].name).toBe("bar");
+  });
+
+  it("ignores functions without directives", () => {
+    const source = `
+function noDirective(x) { return x; }
+
+/**
+ * @nudo:case "test" (T.number)
+ */
+function withDirective(x) { return x + 1; }
+`;
+    const ast = parse(source);
+    const results = extractDirectives(ast);
+    expect(results).toHaveLength(1);
+    expect(results[0].name).toBe("withDirective");
+  });
+
+  it("handles string arguments in case", () => {
+    const source = `
+/**
+ * @nudo:case "string test" ("hello", "world")
+ */
+function greet(a, b) { return a + b; }
+`;
+    const ast = parse(source);
+    const results = extractDirectives(ast);
+    expect(results[0].directives[0].args).toHaveLength(2);
+    expect(typeValueEquals(results[0].directives[0].args[0], T.literal("hello"))).toBe(true);
+    expect(typeValueEquals(results[0].directives[0].args[1], T.literal("world"))).toBe(true);
+  });
+});

package/src/directives.ts

@@ -0,0 +1,312 @@
+import type { Node, Comment } from "@babel/types";
+import { type TypeValue, T } from "@nudojs/core";
+
+export type CaseDirective = {
+  kind: "case";
+  name: string;
+  args: TypeValue[];
+  expected?: TypeValue;
+  commentLine?: number;
+};
+
+export type MockDirective = {
+  kind: "mock";
+  name: string;
+  expression?: string;
+  fromPath?: string;
+};
+
+export type PureDirective = {
+  kind: "pure";
+};
+
+export type SkipDirective = {
+  kind: "skip";
+  returns?: TypeValue;
+};
+
+export type SampleDirective = {
+  kind: "sample";
+  count: number;
+};
+
+export type ReturnsDirective = {
+  kind: "returns";
+  expected: TypeValue;
+};
+
+export type Directive = CaseDirective | MockDirective | PureDirective | SkipDirective | SampleDirective | ReturnsDirective;
+
+export type FunctionWithDirectives = {
+  node: Node;
+  name: string;
+  directives: Directive[];
+};
+
+const CASE_NAME_REGEX = /@nudo:case\s+"([^"]+)"\s*\(/g;
+const MOCK_INLINE_REGEX = /@nudo:mock\s+(\w+)\s*=\s*(.+)/g;
+const MOCK_FROM_REGEX = /@nudo:mock\s+(\w+)\s+from\s+"([^"]+)"/g;
+const PURE_REGEX = /@nudo:pure\b/g;
+const SKIP_REGEX = /@nudo:skip(?:\s+(.+))?/g;
+const SAMPLE_REGEX = /@nudo:sample\s+(\d+)/g;
+const RETURNS_REGEX = /@nudo:returns\s*\(/g;
+
+export function parseTypeValueExpr(expr: string): TypeValue {
+  const s = expr.trim();
+
+  if (s === "T.number") return T.number;
+  if (s === "T.string") return T.string;
+  if (s === "T.boolean") return T.boolean;
+  if (s === "T.unknown") return T.unknown;
+  if (s === "T.never") return T.never;
+  if (s === "T.null") return T.null;
+  if (s === "T.undefined") return T.undefined;
+
+  if (s === "true") return T.literal(true);
+  if (s === "false") return T.literal(false);
+  if (s === "null") return T.literal(null);
+  if (s === "undefined") return T.literal(undefined);
+
+  const literalMatch = s.match(/^T\.literal\((.+)\)$/);
+  if (literalMatch) {
+    return T.literal(parsePrimitiveValue(literalMatch[1].trim()));
+  }
+
+  if (s.startsWith("T.union(") && s.endsWith(")")) {
+    const inner = s.slice("T.union(".length, -1);
+    const args = splitTopLevelArgs(inner);
+    return T.union(...args.map(parseTypeValueExpr));
+  }
+
+  if (s.startsWith("T.array(") && s.endsWith(")")) {
+    const inner = s.slice("T.array(".length, -1);
+    return T.array(parseTypeValueExpr(inner));
+  }
+
+  if (s.startsWith("T.tuple(") && s.endsWith(")")) {
+    const inner = s.slice("T.tuple(".length, -1).trim();
+    if (inner.startsWith("[") && inner.endsWith("]")) {
+      const elements = splitTopLevelArgs(inner.slice(1, -1));
+      return T.tuple(elements.map(parseTypeValueExpr));
+    }
+    return T.tuple([]);
+  }
+
+  if (s.startsWith("T.object(") && s.endsWith(")")) {
+    const inner = s.slice("T.object(".length, -1).trim();
+    if (inner.startsWith("{") && inner.endsWith("}")) {
+      const content = inner.slice(1, -1).trim();
+      if (!content) return T.object({});
+      const entries = splitTopLevelArgs(content);
+      const props: Record<string, TypeValue> = {};
+      for (const entry of entries) {
+        const colonIdx = entry.indexOf(":");
+        if (colonIdx === -1) continue;
+        const key = entry.slice(0, colonIdx).trim();
+        const val = entry.slice(colonIdx + 1).trim();
+        props[key] = parseTypeValueExpr(val);
+      }
+      return T.object(props);
+    }
+    return T.object({});
+  }
+
+  if (/^-?\d+(\.\d+)?$/.test(s)) return T.literal(Number(s));
+
+  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+    return T.literal(s.slice(1, -1));
+  }
+
+  if (s.startsWith("{") && s.endsWith("}")) {
+    const content = s.slice(1, -1).trim();
+    if (!content) return T.object({});
+    const entries = splitTopLevelArgs(content);
+    const props: Record<string, TypeValue> = {};
+    for (const entry of entries) {
+      const colonIdx = findTopLevelColon(entry);
+      if (colonIdx === -1) continue;
+      const key = entry.slice(0, colonIdx).trim().replace(/^["']|["']$/g, "");
+      const val = entry.slice(colonIdx + 1).trim();
+      props[key] = parseTypeValueExpr(val);
+    }
+    return T.object(props);
+  }
+
+  if (s.startsWith("[") && s.endsWith("]")) {
+    const content = s.slice(1, -1).trim();
+    if (!content) return T.tuple([]);
+    const elements = splitTopLevelArgs(content);
+    return T.tuple(elements.map(parseTypeValueExpr));
+  }
+
+  return T.unknown;
+}
+
+function parsePrimitiveValue(s: string): string | number | boolean | null | undefined {
+  if (s === "true") return true;
+  if (s === "false") return false;
+  if (s === "null") return null;
+  if (s === "undefined") return undefined;
+  if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
+  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1);
+  }
+  return s;
+}
+
+function splitTopLevelArgs(s: string): string[] {
+  const result: string[] = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of s) {
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    if (ch === ")" || ch === "]" || ch === "}") depth--;
+    if (ch === "," && depth === 0) {
+      result.push(current.trim());
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) result.push(current.trim());
+  return result;
+}
+
+function findTopLevelColon(s: string): number {
+  let depth = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    if (ch === ")" || ch === "]" || ch === "}") depth--;
+    if (ch === ":" && depth === 0) return i;
+  }
+  return -1;
+}
+
+function extractBalancedParens(text: string, startIdx: number): string | null {
+  if (text[startIdx] !== "(") return null;
+  let depth = 0;
+  for (let i = startIdx; i < text.length; i++) {
+    if (text[i] === "(") depth++;
+    if (text[i] === ")") depth--;
+    if (depth === 0) return text.slice(startIdx + 1, i);
+  }
+  return null;
+}
+
+function parseDirectivesFromComments(comments: readonly Comment[]): Directive[] {
+  const directives: Directive[] = [];
+  for (const comment of comments) {
+    const text = comment.value;
+
+    MOCK_FROM_REGEX.lastIndex = 0;
+    let mockFromMatch: RegExpExecArray | null;
+    const mockFromRanges: [number, number][] = [];
+    while ((mockFromMatch = MOCK_FROM_REGEX.exec(text)) !== null) {
+      directives.push({
+        kind: "mock",
+        name: mockFromMatch[1],
+        fromPath: mockFromMatch[2],
+      });
+      mockFromRanges.push([mockFromMatch.index, mockFromMatch.index + mockFromMatch[0].length]);
+    }
+
+    MOCK_INLINE_REGEX.lastIndex = 0;
+    let mockMatch: RegExpExecArray | null;
+    while ((mockMatch = MOCK_INLINE_REGEX.exec(text)) !== null) {
+      const inFromRange = mockFromRanges.some(
+        ([s, e]) => mockMatch!.index >= s && mockMatch!.index < e,
+      );
+      if (inFromRange) continue;
+      directives.push({
+        kind: "mock",
+        name: mockMatch[1],
+        expression: mockMatch[2].trim(),
+      });
+    }
+
+    CASE_NAME_REGEX.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    const commentStartLine = comment.loc?.start.line ?? 0;
+    while ((match = CASE_NAME_REGEX.exec(text)) !== null) {
+      const name = match[1];
+      const parenStart = match.index + match[0].length - 1;
+      const argsStr = extractBalancedParens(text, parenStart);
+      if (argsStr === null) continue;
+      const args = splitTopLevelArgs(argsStr).map(parseTypeValueExpr);
+
+      const afterParen = parenStart + argsStr.length + 2;
+      const restLine = text.slice(afterParen).split("\n")[0].trim();
+      const arrowMatch = restLine.match(/^=>\s*(.+)/);
+      const expected = arrowMatch ? parseTypeValueExpr(arrowMatch[1].trim()) : undefined;
+
+      const linesBeforeMatch = text.slice(0, match.index).split("\n").length - 1;
+      const commentLine = commentStartLine + linesBeforeMatch;
+
+      directives.push({ kind: "case", name, args, expected, commentLine });
+    }
+
+    PURE_REGEX.lastIndex = 0;
+    if (PURE_REGEX.test(text)) {
+      directives.push({ kind: "pure" });
+    }
+
+    SKIP_REGEX.lastIndex = 0;
+    let skipMatch: RegExpExecArray | null;
+    while ((skipMatch = SKIP_REGEX.exec(text)) !== null) {
+      const returnsExpr = skipMatch[1]?.trim();
+      directives.push({
+        kind: "skip",
+        returns: returnsExpr ? parseTypeValueExpr(returnsExpr) : undefined,
+      });
+    }
+
+    SAMPLE_REGEX.lastIndex = 0;
+    let sampleMatch: RegExpExecArray | null;
+    while ((sampleMatch = SAMPLE_REGEX.exec(text)) !== null) {
+      directives.push({ kind: "sample", count: Number(sampleMatch[1]) });
+    }
+
+    RETURNS_REGEX.lastIndex = 0;
+    let returnsMatch: RegExpExecArray | null;
+    while ((returnsMatch = RETURNS_REGEX.exec(text)) !== null) {
+      const parenStart = returnsMatch.index + returnsMatch[0].length - 1;
+      const argsStr = extractBalancedParens(text, parenStart);
+      if (argsStr === null) continue;
+      directives.push({ kind: "returns", expected: parseTypeValueExpr(argsStr) });
+    }
+  }
+  return directives;
+}
+
+function getFunctionName(node: Node): string {
+  if (node.type === "FunctionDeclaration" && node.id) return node.id.name;
+  if (node.type === "ExportDefaultDeclaration" && node.declaration.type === "FunctionDeclaration" && node.declaration.id) {
+    return node.declaration.id.name;
+  }
+  if (node.type === "VariableDeclaration") {
+    const decl = node.declarations[0];
+    if (decl.id.type === "Identifier") return decl.id.name;
+  }
+  return "<anonymous>";
+}
+
+export function extractDirectives(ast: Node): FunctionWithDirectives[] {
+  const results: FunctionWithDirectives[] = [];
+
+  if (ast.type !== "File") return results;
+  const body = ast.program.body;
+
+  for (const stmt of body) {
+    const leadingComments = stmt.leadingComments;
+    if (!leadingComments || leadingComments.length === 0) continue;
+
+    const directives = parseDirectivesFromComments(leadingComments);
+    if (directives.length === 0) continue;
+
+    const name = getFunctionName(stmt);
+    results.push({ node: stmt, name, directives });
+  }
+
+  return results;
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export { parse } from "./parse.ts";
+export {
+  type Directive,
+  type CaseDirective,
+  type MockDirective,
+  type PureDirective,
+  type SkipDirective,
+  type SampleDirective,
+  type ReturnsDirective,
+  type FunctionWithDirectives,
+  extractDirectives,
+  parseTypeValueExpr,
+} from "./directives.ts";

package/src/parse.ts

@@ -0,0 +1,10 @@
+import { parse as babelParse } from "@babel/parser";
+import type { File } from "@babel/types";
+
+export function parse(source: string): File {
+  return babelParse(source, {
+    sourceType: "module",
+    plugins: ["typescript", "jsx"],
+    attachComment: true,
+  });
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"],
+  "references": [{ "path": "../core" }]
+}