@nudojs/parser 0.2.0 → 0.3.1

package/package.json

@@ -1,23 +1,42 @@
 {
   "name": "@nudojs/parser",
-  "version": "0.2.0",
+  "version": "0.3.1",
+  "description": "Babel-based parser and directive extraction for Nudo",
   "type": "module",
-  "main": "src/index.ts",
+  "license": "MIT",
+  "keywords": [
+    "nudo",
+    "type-inference",
+    "javascript",
+    "parser",
+    "babel",
+    "directives"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
   },
+  "files": [
+    "dist"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/nudojs/nudo.git",
     "directory": "packages/parser"
   },
+  "homepage": "https://github.com/nudojs/nudo/tree/main/packages/parser",
+  "bugs": "https://github.com/nudojs/nudo/issues",
   "publishConfig": {
     "access": "public",
     "provenance": true,
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@nudojs/core": "0.2.0"
+    "@nudojs/core": "0.3.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts"

package/CHANGELOG.md

@@ -1,27 +0,0 @@
-# @nudojs/parser
-
-## 0.2.0
-
-### Minor Changes
-
-- 6c38283: docs and ci
-- 9f7f819: fix pkg info
-- c175f71: version
-
-### Patch Changes
-
-- Updated dependencies [6c38283]
-- Updated dependencies [9f7f819]
-- Updated dependencies [c175f71]
-  - @nudojs/core@0.2.0
-
-## 0.1.0
-
-### Minor Changes
-
-- Conceptual design and basic implementation.
-
-### Patch Changes
-
-- Updated dependencies
-  - @nudojs/core@0.1.0

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

@@ -1,113 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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);
-  });
-});