@nudojs/cli 0.2.0 → 0.3.0

package/src/__tests__/evaluator-string-methods.test.ts

@@ -1,151 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { T, typeValueEquals, createEnvironment } from "@nudojs/core";
-import { evaluateProgram } from "../evaluator.ts";
-import { parse } from "@nudojs/parser";
-import type { TypeValue } from "@nudojs/core";
-
-function evalExpr(code: string): TypeValue {
-  const ast = parse(code);
-  const env = createEnvironment();
-  return evaluateProgram(ast, env);
-}
-
-function evalWith(code: string, bindings: Record<string, TypeValue>): TypeValue {
-  const ast = parse(code);
-  const env = createEnvironment();
-  for (const [k, v] of Object.entries(bindings)) env.bind(k, v);
-  return evaluateProgram(ast, env);
-}
-
-describe("String methods - literal receiver", () => {
-  it("toUpperCase", () => {
-    expect(typeValueEquals(evalExpr('"hello".toUpperCase()'), T.literal("HELLO"))).toBe(true);
-  });
-
-  it("toLowerCase", () => {
-    expect(typeValueEquals(evalExpr('"HELLO".toLowerCase()'), T.literal("hello"))).toBe(true);
-  });
-
-  it("trim", () => {
-    expect(typeValueEquals(evalExpr('"  hi  ".trim()'), T.literal("hi"))).toBe(true);
-  });
-
-  it("trimStart", () => {
-    expect(typeValueEquals(evalExpr('"  hi".trimStart()'), T.literal("hi"))).toBe(true);
-  });
-
-  it("trimEnd", () => {
-    expect(typeValueEquals(evalExpr('"hi  ".trimEnd()'), T.literal("hi"))).toBe(true);
-  });
-
-  it("charAt", () => {
-    expect(typeValueEquals(evalExpr('"abc".charAt(1)'), T.literal("b"))).toBe(true);
-  });
-
-  it("charCodeAt", () => {
-    expect(typeValueEquals(evalExpr('"A".charCodeAt(0)'), T.literal(65))).toBe(true);
-  });
-
-  it("at", () => {
-    expect(typeValueEquals(evalExpr('"abc".at(-1)'), T.literal("c"))).toBe(true);
-  });
-
-  it("startsWith", () => {
-    expect(typeValueEquals(evalExpr('"hello".startsWith("he")'), T.literal(true))).toBe(true);
-    expect(typeValueEquals(evalExpr('"hello".startsWith("lo")'), T.literal(false))).toBe(true);
-  });
-
-  it("endsWith", () => {
-    expect(typeValueEquals(evalExpr('"hello".endsWith("lo")'), T.literal(true))).toBe(true);
-    expect(typeValueEquals(evalExpr('"hello".endsWith("he")'), T.literal(false))).toBe(true);
-  });
-
-  it("includes", () => {
-    expect(typeValueEquals(evalExpr('"hello".includes("ell")'), T.literal(true))).toBe(true);
-    expect(typeValueEquals(evalExpr('"hello".includes("xyz")'), T.literal(false))).toBe(true);
-  });
-
-  it("indexOf", () => {
-    expect(typeValueEquals(evalExpr('"hello".indexOf("l")'), T.literal(2))).toBe(true);
-    expect(typeValueEquals(evalExpr('"hello".indexOf("z")'), T.literal(-1))).toBe(true);
-  });
-
-  it("lastIndexOf", () => {
-    expect(typeValueEquals(evalExpr('"hello".lastIndexOf("l")'), T.literal(3))).toBe(true);
-  });
-
-  it("slice", () => {
-    expect(typeValueEquals(evalExpr('"hello".slice(1, 3)'), T.literal("el"))).toBe(true);
-    expect(typeValueEquals(evalExpr('"hello".slice(2)'), T.literal("llo"))).toBe(true);
-  });
-
-  it("substring", () => {
-    expect(typeValueEquals(evalExpr('"hello".substring(1, 4)'), T.literal("ell"))).toBe(true);
-  });
-
-  it("split", () => {
-    const result = evalExpr('"a,b,c".split(",")');
-    expect(result.kind).toBe("tuple");
-    if (result.kind === "tuple") {
-      expect(result.elements.length).toBe(3);
-      expect(typeValueEquals(result.elements[0], T.literal("a"))).toBe(true);
-      expect(typeValueEquals(result.elements[1], T.literal("b"))).toBe(true);
-      expect(typeValueEquals(result.elements[2], T.literal("c"))).toBe(true);
-    }
-  });
-
-  it("replace", () => {
-    expect(typeValueEquals(evalExpr('"hello".replace("l", "r")'), T.literal("herlo"))).toBe(true);
-  });
-
-  it("replaceAll", () => {
-    expect(typeValueEquals(evalExpr('"hello".replaceAll("l", "r")'), T.literal("herro"))).toBe(true);
-  });
-
-  it("repeat", () => {
-    expect(typeValueEquals(evalExpr('"ab".repeat(3)'), T.literal("ababab"))).toBe(true);
-  });
-
-  it("padStart", () => {
-    expect(typeValueEquals(evalExpr('"5".padStart(3, "0")'), T.literal("005"))).toBe(true);
-  });
-
-  it("padEnd", () => {
-    expect(typeValueEquals(evalExpr('"5".padEnd(3, "0")'), T.literal("500"))).toBe(true);
-  });
-});
-
-describe("String methods - abstract receiver", () => {
-  it("toUpperCase returns string", () => {
-    const result = evalWith("x.toUpperCase()", { x: T.string });
-    expect(typeValueEquals(result, T.string)).toBe(true);
-  });
-
-  it("startsWith returns boolean", () => {
-    const result = evalWith('x.startsWith("a")', { x: T.string });
-    expect(typeValueEquals(result, T.boolean)).toBe(true);
-  });
-
-  it("indexOf returns number", () => {
-    const result = evalWith('x.indexOf("a")', { x: T.string });
-    expect(typeValueEquals(result, T.number)).toBe(true);
-  });
-
-  it("split returns string[]", () => {
-    const result = evalWith('x.split(",")', { x: T.string });
-    expect(result.kind).toBe("array");
-    if (result.kind === "array") {
-      expect(typeValueEquals(result.element, T.string)).toBe(true);
-    }
-  });
-
-  it("charAt returns string", () => {
-    const result = evalWith("x.charAt(0)", { x: T.string });
-    expect(typeValueEquals(result, T.string)).toBe(true);
-  });
-
-  it("slice returns string", () => {
-    const result = evalWith("x.slice(1)", { x: T.string });
-    expect(typeValueEquals(result, T.string)).toBe(true);
-  });
-});

package/src/__tests__/evaluator.test.ts

@@ -1,243 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { T, typeValueEquals, typeValueToString, createEnvironment } from "@nudojs/core";
-import { parse, extractDirectives } from "@nudojs/parser";
-import { evaluateFunction, evaluateProgram } from "../evaluator.ts";
-
-function inferFromSource(source: string) {
-  const ast = parse(source);
-  const functions = extractDirectives(ast);
-  const env = createEnvironment();
-  return functions.map((fn) => ({
-    name: fn.name,
-    cases: fn.directives.map((d) => ({
-      caseName: d.name,
-      result: evaluateFunction(fn.node, d.args, env),
-    })),
-  }));
-}
-
-describe("End-to-end: calc example from design doc", () => {
-  const source = `
-/**
- * @nudo:case "concrete" (1, 2)
- * @nudo:case "symbolic" (T.number, T.number)
- */
-function calc(a, b) {
-  if (a > b) return a - b;
-  return a + b;
-}
-`;
-
-  it("infers concrete case: calc(1, 2) => 3", () => {
-    const results = inferFromSource(source);
-    expect(results).toHaveLength(1);
-    expect(results[0].name).toBe("calc");
-    const concreteCase = results[0].cases[0];
-    expect(concreteCase.caseName).toBe("concrete");
-    expect(typeValueEquals(concreteCase.result, T.literal(3))).toBe(true);
-  });
-
-  it("infers symbolic case: calc(number, number) => number", () => {
-    const results = inferFromSource(source);
-    const symbolicCase = results[0].cases[1];
-    expect(symbolicCase.caseName).toBe("symbolic");
-    expect(typeValueEquals(symbolicCase.result, T.number)).toBe(true);
-  });
-});
-
-describe("End-to-end: subtract example", () => {
-  const source = `
-/**
- * @nudo:case "positive numbers" (5, 3)
- * @nudo:case "negative result" (1, 10)
- * @nudo:case "symbolic" (T.number, T.number)
- */
-function subtract(a, b) {
-  return a - b;
-}
-`;
-
-  it("infers subtract(5, 3) => 2", () => {
-    const results = inferFromSource(source);
-    const c = results[0].cases[0];
-    expect(typeValueEquals(c.result, T.literal(2))).toBe(true);
-  });
-
-  it("infers subtract(1, 10) => -9", () => {
-    const results = inferFromSource(source);
-    const c = results[0].cases[1];
-    expect(typeValueEquals(c.result, T.literal(-9))).toBe(true);
-  });
-
-  it("infers subtract(number, number) => number", () => {
-    const results = inferFromSource(source);
-    const c = results[0].cases[2];
-    expect(typeValueEquals(c.result, T.number)).toBe(true);
-  });
-});
-
-describe("End-to-end: typeof narrowing", () => {
-  const source = `
-/**
- * @nudo:case "with number" (42)
- * @nudo:case "with string" ("hello")
- * @nudo:case "symbolic" (T.union(T.number, T.string))
- */
-function describe(x) {
-  if (typeof x === "number") return x + 1;
-  return x;
-}
-`;
-
-  it("infers describe(42) => 43", () => {
-    const results = inferFromSource(source);
-    const c = results[0].cases[0];
-    expect(typeValueEquals(c.result, T.literal(43))).toBe(true);
-  });
-
-  it("infers describe('hello') => 'hello'", () => {
-    const results = inferFromSource(source);
-    const c = results[0].cases[1];
-    expect(typeValueEquals(c.result, T.literal("hello"))).toBe(true);
-  });
-
-  it("infers describe(number | string) => number | string", () => {
-    const results = inferFromSource(source);
-    const c = results[0].cases[2];
-    expect(typeValueToString(c.result)).toBe("number | string");
-  });
-});
-
-describe("End-to-end: strict equality narrowing", () => {
-  const source = `
-/**
- * @nudo:case "null case" (null)
- * @nudo:case "number case" (5)
- * @nudo:case "symbolic" (T.union(T.null, T.number))
- */
-function safe(x) {
-  if (x === null) return 0;
-  return x;
-}
-`;
-
-  it("infers safe(null) => 0", () => {
-    const results = inferFromSource(source);
-    const c = results[0].cases[0];
-    expect(typeValueEquals(c.result, T.literal(0))).toBe(true);
-  });
-
-  it("infers safe(5) => 5", () => {
-    const results = inferFromSource(source);
-    const c = results[0].cases[1];
-    expect(typeValueEquals(c.result, T.literal(5))).toBe(true);
-  });
-
-  it("infers safe(null | number) => 0 | number", () => {
-    const results = inferFromSource(source);
-    const c = results[0].cases[2];
-    const str = typeValueToString(c.result);
-    expect(str === "0 | number" || str === "number | 0").toBe(true);
-  });
-});
-
-describe("Evaluator: basic expressions", () => {
-  it("evaluates arithmetic", () => {
-    const ast = parse("1 + 2 * 3");
-    const env = createEnvironment();
-    const result = evaluateProgram(ast, env);
-    expect(typeValueEquals(result, T.literal(7))).toBe(true);
-  });
-
-  it("evaluates variable declaration and usage", () => {
-    const ast = parse("const x = 10; x + 5;");
-    const env = createEnvironment();
-    const result = evaluateProgram(ast, env);
-    expect(typeValueEquals(result, T.literal(15))).toBe(true);
-  });
-
-  it("evaluates ternary expression", () => {
-    const ast = parse("true ? 1 : 2");
-    const env = createEnvironment();
-    const result = evaluateProgram(ast, env);
-    expect(typeValueEquals(result, T.literal(1))).toBe(true);
-  });
-
-  it("evaluates object literal", () => {
-    const ast = parse('const obj = { x: 1, y: "hi" }; obj.x;');
-    const env = createEnvironment();
-    const result = evaluateProgram(ast, env);
-    expect(typeValueEquals(result, T.literal(1))).toBe(true);
-  });
-
-  it("evaluates array literal", () => {
-    const ast = parse("const arr = [1, 2, 3]; arr.length;");
-    const env = createEnvironment();
-    const result = evaluateProgram(ast, env);
-    expect(typeValueEquals(result, T.literal(3))).toBe(true);
-  });
-
-  it("evaluates function call", () => {
-    const ast = parse(`
-      function add(a, b) { return a + b; }
-      add(3, 4);
-    `);
-    const env = createEnvironment();
-    const result = evaluateProgram(ast, env);
-    expect(typeValueEquals(result, T.literal(7))).toBe(true);
-  });
-
-  it("evaluates arrow function", () => {
-    const ast = parse(`
-      const double = (x) => x + x;
-      double(5);
-    `);
-    const env = createEnvironment();
-    const result = evaluateProgram(ast, env);
-    expect(typeValueEquals(result, T.literal(10))).toBe(true);
-  });
-
-  it("evaluates logical operators", () => {
-    const ast = parse("true && 42");
-    const env = createEnvironment();
-    const result = evaluateProgram(ast, env);
-    expect(typeValueEquals(result, T.literal(42))).toBe(true);
-
-    const ast2 = parse("false || 99");
-    const result2 = evaluateProgram(ast2, createEnvironment());
-    expect(typeValueEquals(result2, T.literal(99))).toBe(true);
-  });
-
-  it("evaluates nullish coalescing", () => {
-    const ast = parse("null ?? 42");
-    const env = createEnvironment();
-    const result = evaluateProgram(ast, env);
-    expect(typeValueEquals(result, T.literal(42))).toBe(true);
-
-    const ast2 = parse("1 ?? 42");
-    const result2 = evaluateProgram(ast2, createEnvironment());
-    expect(typeValueEquals(result2, T.literal(1))).toBe(true);
-  });
-
-  it("evaluates unary operators", () => {
-    const ast = parse("typeof 42");
-    const env = createEnvironment();
-    const result = evaluateProgram(ast, env);
-    expect(typeValueEquals(result, T.literal("number"))).toBe(true);
-
-    const ast2 = parse("!true");
-    const result2 = evaluateProgram(ast2, createEnvironment());
-    expect(typeValueEquals(result2, T.literal(false))).toBe(true);
-
-    const ast3 = parse("-5");
-    const result3 = evaluateProgram(ast3, createEnvironment());
-    expect(typeValueEquals(result3, T.literal(-5))).toBe(true);
-  });
-
-  it("evaluates template literal", () => {
-    const ast = parse("`hello`");
-    const env = createEnvironment();
-    const result = evaluateProgram(ast, env);
-    expect(typeValueEquals(result, T.literal("hello"))).toBe(true);
-  });
-});

package/src/__tests__/narrowing.test.ts

@@ -1,82 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { T, typeValueEquals, typeValueToString, createEnvironment } from "@nudojs/core";
-import { parse } from "@nudojs/parser";
-import { narrow } from "../narrowing.ts";
-import type { ExpressionStatement } from "@babel/types";
-
-function getTestExpr(source: string) {
-  const ast = parse(source);
-  const stmt = ast.program.body[0] as ExpressionStatement;
-  return stmt.expression;
-}
-
-describe("narrow: typeof", () => {
-  it("narrows typeof x === 'number' on union", () => {
-    const env = createEnvironment();
-    env.bind("x", T.union(T.number, T.string));
-    const expr = getTestExpr('typeof x === "number"');
-    const [trueEnv, falseEnv] = narrow(expr, env);
-    expect(typeValueEquals(trueEnv.lookup("x"), T.number)).toBe(true);
-    expect(typeValueEquals(falseEnv.lookup("x"), T.string)).toBe(true);
-  });
-
-  it("narrows typeof x === 'string' on union", () => {
-    const env = createEnvironment();
-    env.bind("x", T.union(T.number, T.string, T.boolean));
-    const expr = getTestExpr('typeof x === "string"');
-    const [trueEnv, falseEnv] = narrow(expr, env);
-    expect(typeValueEquals(trueEnv.lookup("x"), T.string)).toBe(true);
-    const falseType = falseEnv.lookup("x");
-    expect(typeValueToString(falseType)).toBe("number | boolean");
-  });
-
-  it("narrows typeof x !== 'number' (inverted)", () => {
-    const env = createEnvironment();
-    env.bind("x", T.union(T.number, T.string));
-    const expr = getTestExpr('typeof x !== "number"');
-    const [trueEnv, falseEnv] = narrow(expr, env);
-    expect(typeValueEquals(trueEnv.lookup("x"), T.string)).toBe(true);
-    expect(typeValueEquals(falseEnv.lookup("x"), T.number)).toBe(true);
-  });
-});
-
-describe("narrow: strict equality", () => {
-  it("narrows x === null", () => {
-    const env = createEnvironment();
-    env.bind("x", T.union(T.null, T.number));
-    const expr = getTestExpr("x === null");
-    const [trueEnv, falseEnv] = narrow(expr, env);
-    expect(typeValueEquals(trueEnv.lookup("x"), T.null)).toBe(true);
-    expect(typeValueEquals(falseEnv.lookup("x"), T.number)).toBe(true);
-  });
-
-  it("narrows x === 1", () => {
-    const env = createEnvironment();
-    env.bind("x", T.union(T.literal(1), T.literal(2), T.literal(3)));
-    const expr = getTestExpr("x === 1");
-    const [trueEnv, falseEnv] = narrow(expr, env);
-    expect(typeValueEquals(trueEnv.lookup("x"), T.literal(1))).toBe(true);
-    const falseType = falseEnv.lookup("x");
-    expect(typeValueToString(falseType)).toBe("2 | 3");
-  });
-
-  it("narrows x !== 1 (inverted)", () => {
-    const env = createEnvironment();
-    env.bind("x", T.union(T.literal(1), T.literal(2)));
-    const expr = getTestExpr("x !== 1");
-    const [trueEnv, falseEnv] = narrow(expr, env);
-    expect(typeValueEquals(trueEnv.lookup("x"), T.literal(2))).toBe(true);
-    expect(typeValueEquals(falseEnv.lookup("x"), T.literal(1))).toBe(true);
-  });
-});
-
-describe("narrow: negation", () => {
-  it("narrows !(typeof x === 'number')", () => {
-    const env = createEnvironment();
-    env.bind("x", T.union(T.number, T.string));
-    const expr = getTestExpr('!(typeof x === "number")');
-    const [trueEnv, falseEnv] = narrow(expr, env);
-    expect(typeValueEquals(trueEnv.lookup("x"), T.string)).toBe(true);
-    expect(typeValueEquals(falseEnv.lookup("x"), T.number)).toBe(true);
-  });
-});

package/tsconfig.json

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