@nudojs/service 0.1.0

package/src/__tests__/analyzer.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect } from "vitest";
+import { resolve } from "node:path";
+import { T, typeValueToString } from "@nudojs/core";
+import { analyzeFile, getTypeAtPosition, getCompletionsAtPosition } from "../analyzer.ts";
+
+const FIXTURE_PATH = resolve(import.meta.dirname, "fixtures", "sample.js");
+
+const SAMPLE_SOURCE = `
+/**
+ * @nudo:case "concrete" (1, 2)
+ * @nudo:case "symbolic" (T.number, T.number)
+ */
+function add(a, b) {
+  return a + b;
+}
+
+/**
+ * @nudo:case "test" ({ name: "Alice", age: 30 })
+ */
+function greet({ name, age }) {
+  return name;
+}
+`;
+
+const THROWS_SOURCE = `
+/**
+ * @nudo:case "valid" (10)
+ * @nudo:case "negative" (-1)
+ */
+function safeSqrt(x) {
+  if (x < 0) {
+    throw new RangeError("negative input");
+  }
+  return x;
+}
+`;
+
+const OBJ_SOURCE = `
+const obj = { x: 1, y: "hello", z: true };
+
+/**
+ * @nudo:case "test" (T.number)
+ */
+function identity(x) {
+  return x;
+}
+`;
+
+describe("analyzeFile", () => {
+  it("analyzes functions with @nudo:case directives", () => {
+    const result = analyzeFile("/test/sample.js", SAMPLE_SOURCE);
+    expect(result.functions).toHaveLength(2);
+
+    const addFn = result.functions[0];
+    expect(addFn.name).toBe("add");
+    expect(addFn.cases).toHaveLength(2);
+    expect(addFn.cases[0].name).toBe("concrete");
+    expect(typeValueToString(addFn.cases[0].result)).toBe("3");
+    expect(addFn.cases[1].name).toBe("symbolic");
+    expect(typeValueToString(addFn.cases[1].result)).toBe("number");
+  });
+
+  it("provides combined type for multiple cases", () => {
+    const result = analyzeFile("/test/sample.js", SAMPLE_SOURCE);
+    const addFn = result.functions[0];
+    expect(addFn.combined).toBeDefined();
+    expect(typeValueToString(addFn.combined!)).toBe("3 | number");
+  });
+
+  it("reports throws as diagnostics", () => {
+    const result = analyzeFile("/test/throws.js", THROWS_SOURCE);
+    expect(result.functions).toHaveLength(1);
+    const fn = result.functions[0];
+    expect(fn.cases).toHaveLength(2);
+
+    const negativeCaseThrows = fn.cases[1].throws;
+    expect(negativeCaseThrows.kind).not.toBe("never");
+  });
+
+  it("returns source locations for functions", () => {
+    const result = analyzeFile("/test/sample.js", SAMPLE_SOURCE);
+    const addFn = result.functions[0];
+    expect(addFn.loc.start.line).toBeGreaterThan(0);
+    expect(addFn.loc.end.line).toBeGreaterThan(addFn.loc.start.line);
+  });
+
+  it("collects top-level bindings", () => {
+    const result = analyzeFile("/test/obj.js", OBJ_SOURCE);
+    expect(result.bindings.has("obj")).toBe(true);
+    const objBinding = result.bindings.get("obj")!;
+    expect(objBinding.type.kind).toBe("object");
+  });
+});
+
+describe("getTypeAtPosition", () => {
+  it("returns type for identifier at position", () => {
+    const source = `const x = 42;\nconst y = x;\n`;
+    const tv = getTypeAtPosition("/test/pos.js", source, 1, 6);
+    expect(tv).not.toBeNull();
+  });
+
+  it("returns null for empty position", () => {
+    const source = `\n\n\n`;
+    const tv = getTypeAtPosition("/test/empty.js", source, 2, 0);
+    expect(tv).toBeNull();
+  });
+});
+
+describe("getCompletionsAtPosition", () => {
+  it("returns variable completions without dot trigger", () => {
+    const source = `const x = 42;\nfunction add(a, b) { return a + b; }\n`;
+    const completions = getCompletionsAtPosition("/test/comp.js", source, 2, 0);
+    expect(completions.length).toBeGreaterThan(0);
+    const names = completions.map((c) => c.label);
+    expect(names).toContain("x");
+    expect(names).toContain("add");
+  });
+
+  it("returns property completions for object after dot", () => {
+    const source = `const obj = { x: 1, y: "hello" };\nobj.x;\n`;
+    const completions = getCompletionsAtPosition("/test/dot.js", source, 2, 4);
+    expect(completions.length).toBeGreaterThan(0);
+    const names = completions.map((c) => c.label);
+    expect(names).toContain("x");
+    expect(names).toContain("y");
+  });
+
+  it("returns array method completions after dot", () => {
+    const source = `const arr = [1, 2, 3];\narr.map;\n`;
+    const completions = getCompletionsAtPosition("/test/arr.js", source, 2, 4);
+    const names = completions.map((c) => c.label);
+    expect(names).toContain("map");
+    expect(names).toContain("filter");
+    expect(names).toContain("reduce");
+    expect(names).toContain("length");
+  });
+});

package/src/__tests__/dts-generator.test.ts

@@ -0,0 +1,98 @@
+import { describe, it, expect } from "vitest";
+import { T } from "@nudojs/core";
+import { typeValueToTSType, generateDts } from "../dts-generator.ts";
+import { analyzeFile } from "../analyzer.ts";
+
+describe("typeValueToTSType", () => {
+  it("converts literal number", () => {
+    expect(typeValueToTSType(T.literal(42))).toBe("42");
+  });
+
+  it("converts literal string", () => {
+    expect(typeValueToTSType(T.literal("hello"))).toBe('"hello"');
+  });
+
+  it("converts literal boolean", () => {
+    expect(typeValueToTSType(T.literal(true))).toBe("true");
+  });
+
+  it("converts null and undefined", () => {
+    expect(typeValueToTSType(T.null)).toBe("null");
+    expect(typeValueToTSType(T.undefined)).toBe("undefined");
+  });
+
+  it("converts primitive types", () => {
+    expect(typeValueToTSType(T.number)).toBe("number");
+    expect(typeValueToTSType(T.string)).toBe("string");
+    expect(typeValueToTSType(T.boolean)).toBe("boolean");
+  });
+
+  it("converts object type", () => {
+    const obj = T.object({ x: T.number, y: T.string });
+    expect(typeValueToTSType(obj)).toBe("{ x: number; y: string }");
+  });
+
+  it("converts array type", () => {
+    expect(typeValueToTSType(T.array(T.number))).toBe("number[]");
+  });
+
+  it("converts union array type with parens", () => {
+    expect(typeValueToTSType(T.array(T.union(T.number, T.string)))).toBe("(number | string)[]");
+  });
+
+  it("converts tuple type", () => {
+    expect(typeValueToTSType(T.tuple([T.number, T.string]))).toBe("[number, string]");
+  });
+
+  it("converts promise type", () => {
+    expect(typeValueToTSType(T.promise(T.number))).toBe("Promise<number>");
+  });
+
+  it("converts instance type", () => {
+    expect(typeValueToTSType(T.instanceOf("Error"))).toBe("Error");
+  });
+
+  it("converts union type", () => {
+    expect(typeValueToTSType(T.union(T.number, T.string))).toBe("number | string");
+  });
+
+  it("converts never and unknown", () => {
+    expect(typeValueToTSType(T.never)).toBe("never");
+    expect(typeValueToTSType(T.unknown)).toBe("unknown");
+  });
+});
+
+describe("generateDts", () => {
+  it("generates .d.ts from analysis result", () => {
+    const source = `
+/**
+ * @nudo:case "concrete" (1, 2)
+ * @nudo:case "symbolic" (T.number, T.number)
+ */
+function add(a, b) {
+  return a + b;
+}
+`;
+    const result = analyzeFile("/test/gen.js", source);
+    const dts = generateDts(result);
+    expect(dts).toContain("export declare function add");
+    expect(dts).toContain("): 3;");
+    expect(dts).toContain("): number;");
+  });
+
+  it("generates single overload for single case", () => {
+    const source = `
+/**
+ * @nudo:case "test" (T.number)
+ */
+function identity(x) {
+  return x;
+}
+`;
+    const result = analyzeFile("/test/single.js", source);
+    const dts = generateDts(result);
+    const lines = dts.trim().split("\n");
+    expect(lines).toHaveLength(1);
+    expect(lines[0]).toContain("export declare function identity");
+  });
+});