@nudojs/cli 0.2.1 → 0.3.1

package/src/__tests__/builtin-map.test.ts

@@ -1,129 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parse, extractDirectives, type CaseDirective } from "@nudojs/parser";
-import { typeValueToString, createEnvironment, T } from "@nudojs/core";
-import { evaluateFunctionFull } from "../evaluator.js";
-
-function runTest(source: string): { name: string; caseName: string; result: string }[] {
-  const ast = parse(source);
-  const directives = extractDirectives(ast);
-  const env = createEnvironment();
-  const results: { name: string; caseName: string; result: string }[] = [];
-
-  for (const fn of directives) {
-    const caseDirectives = fn.directives.filter((d): d is CaseDirective => d.kind === "case");
-    for (const dir of caseDirectives) {
-      const result = evaluateFunctionFull(fn.node, dir.args, env);
-      results.push({ name: fn.name, caseName: dir.name, result: typeValueToString(result.value) });
-    }
-  }
-  return results;
-}
-
-describe("Built-in Map API", () => {
-  it("new Map() should create a Map instance", () => {
-    const results = runTest(`
-// @nudo:case "new-map" ()
-function fn() {
-  const m = new Map();
-  return m;
-}
-`);
-    expect(results[0].result).toContain("Map");
-  });
-
-  it("Map.get() should return V | undefined (unknown when V is unknown)", () => {
-    const results = runTest(`
-// @nudo:case "get" ()
-function fn() {
-  const m = new Map();
-  return m.get("key");
-}
-`);
-    // When V is unknown, unknown | undefined simplifies to unknown
-    expect(results[0].result).toBe("unknown");
-  });
-
-  it("Map.has() should return boolean", () => {
-    const results = runTest(`
-// @nudo:case "has" ()
-function fn() {
-  const m = new Map();
-  return m.has("key");
-}
-`);
-    expect(results[0].result).toBe("boolean");
-  });
-
-  it("Map.size should return number", () => {
-    const results = runTest(`
-// @nudo:case "size" ()
-function fn() {
-  const m = new Map();
-  return m.size;
-}
-`);
-    expect(results[0].result).toBe("number");
-  });
-
-  it("arrow function case argument works as Array.map callback", () => {
-    const results = runTest(`
-// @nudo:case "double" ([1, 2, 3], (a) => a * 2)
-function doubleAll(items, cb) {
-  return items.map(cb);
-}
-`);
-    expect(results[0].result).toBe("[2, 4, 6]");
-  });
-
-  it("Map.get() hits literal keys recorded at construction", () => {
-    const results = runTest(`
-// @nudo:case "lookup-table" ()
-function fn() {
-  const typeMap = new Map([['[object Map]', 1], ['[object Set]', 2]]);
-  return [typeMap.get('[object Set]'), typeMap.get('[object Object]')];
-}
-`);
-    // Precise hit returns the stored value; miss returns undefined
-    expect(results[0].result).toBe("[2, undefined]");
-  });
-
-  it("Map.get() tracks keys stored via set()", () => {
-    const results = runTest(`
-// @nudo:case "seen-cache" ()
-function fn() {
-  const seen = new Map();
-  seen.set('obj', 'clone');
-  return seen.get('obj');
-}
-`);
-    expect(results[0].result).toBe('"clone"');
-  });
-
-  it("Map.has() decides literally for recorded keys", () => {
-    const results = runTest(`
-// @nudo:case "has-literal" ()
-function fn() {
-  const m = new Map([['a', 1]]);
-  return m.has('a');
-}
-`);
-    expect(results[0].result).toBe("true");
-  });
-
-  it("for-of on a Map instance iterates [key, value] tuples", () => {
-    const results = runTest(`
-// @nudo:case "forof-entries" ()
-function fn() {
-  const m = new Map([['a', 1], ['b', 2]]);
-  const keys = [];
-  const values = [];
-  for (const [k, v] of m) {
-    keys.push(k);
-    values.push(v);
-  }
-  return [keys, values];
-}
-`);
-    expect(results[0].result).toBe('[["a", "b"], [1, 2]]');
-  });
-});

package/src/__tests__/builtin-promise.test.ts

@@ -1,150 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parse, extractDirectives, type CaseDirective } from "@nudojs/parser";
-import { typeValueToString, createEnvironment, T } from "@nudojs/core";
-import { evaluateFunctionFull } from "../evaluator.js";
-
-function runTest(source: string): { name: string; caseName: string; result: string }[] {
-  const ast = parse(source);
-  const directives = extractDirectives(ast);
-  const env = createEnvironment();
-  const results: { name: string; caseName: string; result: string }[] = [];
-
-  for (const fn of directives) {
-    const caseDirectives = fn.directives.filter((d): d is CaseDirective => d.kind === "case");
-    for (const dir of caseDirectives) {
-      const result = evaluateFunctionFull(fn.node, dir.args, env);
-      results.push({
-        name: fn.name,
-        caseName: dir.name,
-        result: typeValueToString(result.value),
-      });
-    }
-  }
-  return results;
-}
-
-describe("Built-in Promise API", () => {
-  it("Promise.resolve(v) should return Promise<T>", () => {
-    const results = runTest(`
-// @nudo:case "resolve" (42)
-function fn(x) {
-  return Promise.resolve(x);
-}
-`);
-    expect(results[0].result).toBe("Promise<42>");
-  });
-
-  it("Promise.reject(v) should return Promise<never>", () => {
-    const results = runTest(`
-// @nudo:case "reject" ()
-function fn() {
-  return Promise.reject(new Error("fail"));
-}
-`);
-    expect(results[0].result).toBe("Promise<never>");
-  });
-
-  it("Promise.all([...]) should return Promise<[T1, T2]> (tuple)", () => {
-    const results = runTest(`
-// @nudo:case "all" ()
-function fn() {
-  return Promise.all([Promise.resolve(1), Promise.resolve(2)]);
-}
-`);
-    expect(results[0].result).toBe("Promise<[1, 2]>");
-  });
-
-  it("Promise.race([...]) should return Promise<T>", () => {
-    const results = runTest(`
-// @nudo:case "race" ()
-function fn() {
-  return Promise.race([Promise.resolve("a"), Promise.resolve("b")]);
-}
-`);
-    expect(results[0].result).toContain("Promise");
-  });
-
-  it(".then() should return Promise<T>", () => {
-    const results = runTest(`
-// @nudo:case "then" ()
-function fn() {
-  return Promise.resolve(42).then(x => x);
-}
-`);
-    expect(results[0].result).toContain("Promise");
-  });
-
-  it("new Promise with resolve inside setTimeout callback should resolve via static site scan", () => {
-    const results = runTest(`
-// @nudo:case "ctor-async-site" ()
-function fn() {
-  return new Promise((resolve) => {
-    setTimeout(() => resolve('x'), 1);
-  });
-}
-`);
-    expect(results[0].result).toBe('Promise<"x">');
-  });
-
-  it("new Promise with direct synchronous resolve should return Promise<42>", () => {
-    const results = runTest(`
-// @nudo:case "ctor-sync" ()
-function fn() {
-  return new Promise((resolve) => resolve(42));
-}
-`);
-    expect(results[0].result).toBe("Promise<42>");
-  });
-
-  it("new Promise with never-resolving executor should return Promise<never>", () => {
-    const results = runTest(`
-// @nudo:case "ctor-never" ()
-function fn() {
-  return new Promise(() => {});
-}
-`);
-    expect(results[0].result).toBe("Promise<never>");
-  });
-
-  it("new Promise with non-function executor should return Promise<unknown>", () => {
-    const results = runTest(`
-// @nudo:case "ctor-nonfn" ()
-function fn(x) {
-  return new Promise(x);
-}
-`);
-    expect(results[0].result).toBe("Promise<unknown>");
-  });
-
-  it("new Promise should evaluate resolve argument in the executor closure scope", () => {
-    const results = runTest(`
-// @nudo:case "ctor-outer-value" (7)
-function fn(returnValue) {
-  return new Promise((resolve) => {
-    setTimeout(() => resolve(returnValue), 1);
-  });
-}
-`);
-    expect(results[0].result).toBe("Promise<7>");
-  });
-
-  it(".then(cb) end-to-end should propagate the callback's return type", () => {
-    const results = runTest(`
-// @nudo:case "then-chain" (7)
-function fn(v) {
-  return Promise.resolve(v).then(x => [x, x]);
-}
-`);
-    expect(results[0].result).toBe("Promise<[7, 7]>");
-  });
-
-  it("new Promise result should chain through .then", () => {
-    const results = runTest(`
-// @nudo:case "ctor-then" ()
-function fn() {
-  return new Promise((resolve) => resolve('done')).then(x => x);
-}
-`);
-    expect(results[0].result).toBe('Promise<"done">');
-  });
-});

package/src/__tests__/builtin-regexp.test.ts

@@ -1,133 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parse, extractDirectives, type CaseDirective } from "@nudojs/parser";
-import { typeValueToString, createEnvironment, T } from "@nudojs/core";
-import { evaluateFunctionFull } from "../evaluator.js";
-
-function runTest(source: string): { name: string; caseName: string; result: string }[] {
-  const ast = parse(source);
-  const directives = extractDirectives(ast);
-  const env = createEnvironment();
-  const results: { name: string; caseName: string; result: string }[] = [];
-
-  for (const fn of directives) {
-    const caseDirectives = fn.directives.filter((d): d is CaseDirective => d.kind === "case");
-    for (const dir of caseDirectives) {
-      const result = evaluateFunctionFull(fn.node, dir.args, env);
-      results.push({ name: fn.name, caseName: dir.name, result: typeValueToString(result.value) });
-    }
-  }
-  return results;
-}
-
-describe("Built-in RegExp API", () => {
-  it("RegExp literal should create a RegExp instance", () => {
-    const results = runTest(`
-// @nudo:case "regexp-literal" ()
-function fn() {
-  const re = /abc/gi;
-  return re;
-}
-`);
-    expect(results[0].result).toContain("RegExp");
-  });
-
-  it("new RegExp() should create a RegExp instance", () => {
-    const results = runTest(`
-// @nudo:case "new-regexp" ()
-function fn() {
-  const re = new RegExp("abc");
-  return re;
-}
-`);
-    expect(results[0].result).toContain("RegExp");
-  });
-
-  it("RegExp.test() should return boolean", () => {
-    const results = runTest(`
-// @nudo:case "test" ()
-function fn() {
-  const re = /abc/;
-  return re.test("abcdef");
-}
-`);
-    expect(results[0].result).toBe("boolean");
-  });
-
-  it("RegExp.source should return string", () => {
-    const results = runTest(`
-// @nudo:case "source" ()
-function fn() {
-  const re = /abc/gi;
-  return re.source;
-}
-`);
-    expect(results[0].result).toBe("string");
-  });
-
-  it("RegExp.flags should return string", () => {
-    const results = runTest(`
-// @nudo:case "flags" ()
-function fn() {
-  const re = /abc/gi;
-  return re.flags;
-}
-`);
-    expect(results[0].result).toBe("string");
-  });
-
-  it("RegExp.global should return boolean", () => {
-    const results = runTest(`
-// @nudo:case "global" ()
-function fn() {
-  const re = /abc/g;
-  return re.global;
-}
-`);
-    expect(results[0].result).toBe("boolean");
-  });
-
-  it("RegExp.ignoreCase should return boolean", () => {
-    const results = runTest(`
-// @nudo:case "ignoreCase" ()
-function fn() {
-  const re = /abc/i;
-  return re.ignoreCase;
-}
-`);
-    expect(results[0].result).toBe("boolean");
-  });
-
-  it("RegExp.multiline should return boolean", () => {
-    const results = runTest(`
-// @nudo:case "multiline" ()
-function fn() {
-  const re = /abc/m;
-  return re.multiline;
-}
-`);
-    expect(results[0].result).toBe("boolean");
-  });
-
-  it("RegExp.exec() should return union of null and object", () => {
-    const results = runTest(`
-// @nudo:case "exec" ()
-function fn() {
-  const re = /abc/;
-  return re.exec("abcdef");
-}
-`);
-    expect(results[0].result).toContain("null");
-    expect(results[0].result).toContain("{}");
-  });
-
-  it("RegExp.toString() should return string", () => {
-    const results = runTest(`
-// @nudo:case "toString" ()
-function fn() {
-  const re = /abc/gi;
-  return re.toString();
-}
-`);
-    expect(results[0].result).toBe("string");
-  });
-});

package/src/__tests__/builtin-set.test.ts

@@ -1,163 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parse, extractDirectives, type CaseDirective } from "@nudojs/parser";
-import { typeValueToString, createEnvironment, T } from "@nudojs/core";
-import { evaluateFunctionFull } from "../evaluator.js";
-
-function runTest(source: string): { name: string; caseName: string; result: string }[] {
-  const ast = parse(source);
-  const directives = extractDirectives(ast);
-  const env = createEnvironment();
-  const results: { name: string; caseName: string; result: string }[] = [];
-
-  for (const fn of directives) {
-    const caseDirectives = fn.directives.filter((d): d is CaseDirective => d.kind === "case");
-    for (const dir of caseDirectives) {
-      const result = evaluateFunctionFull(fn.node, dir.args, env);
-      results.push({ name: fn.name, caseName: dir.name, result: typeValueToString(result.value) });
-    }
-  }
-  return results;
-}
-
-describe("Built-in Set API", () => {
-  it("new Set() should create a Set instance", () => {
-    const results = runTest(`
-// @nudo:case "new-set" ()
-function fn() {
-  const s = new Set();
-  return s;
-}
-`);
-    expect(results[0].result).toContain("Set");
-  });
-
-  it("Set.has() should return boolean", () => {
-    const results = runTest(`
-// @nudo:case "has" ()
-function fn() {
-  const s = new Set();
-  return s.has("key");
-}
-`);
-    expect(results[0].result).toBe("boolean");
-  });
-
-  it("Set.size should return number", () => {
-    const results = runTest(`
-// @nudo:case "size" ()
-function fn() {
-  const s = new Set();
-  return s.size;
-}
-`);
-    expect(results[0].result).toBe("number");
-  });
-
-  it("Set.add() should return the Set instance", () => {
-    const results = runTest(`
-// @nudo:case "add" ()
-function fn() {
-  const s = new Set();
-  return s.add(42);
-}
-`);
-    expect(results[0].result).toContain("Set");
-  });
-
-  it("new Set([1, 2, 3]) should infer element type", () => {
-    const results = runTest(`
-// @nudo:case "from-array" ()
-function fn() {
-  const s = new Set([1, 2, 3]);
-  return s;
-}
-`);
-    expect(results[0].result).toContain("Set");
-  });
-
-  it("Set.delete() should return boolean", () => {
-    const results = runTest(`
-// @nudo:case "delete" ()
-function fn() {
-  const s = new Set();
-  return s.delete("key");
-}
-`);
-    expect(results[0].result).toBe("boolean");
-  });
-
-  it("Set.clear() should return undefined", () => {
-    const results = runTest(`
-// @nudo:case "clear" ()
-function fn() {
-  const s = new Set();
-  return s.clear();
-}
-`);
-    expect(results[0].result).toBe("undefined");
-  });
-
-  it("Set.has() decides literally for recorded values", () => {
-    const results = runTest(`
-// @nudo:case "has-literal" ()
-function fn() {
-  const s = new Set(['a', 'b']);
-  return [s.has('a'), s.has('z')];
-}
-`);
-    expect(results[0].result).toBe("[true, false]");
-  });
-
-  it("Set.has() decides prototype singletons by identity", () => {
-    const results = runTest(`
-// @nudo:case "has-proto" ()
-function fn() {
-  const protoHack = new Set([Map.prototype, Set.prototype]);
-  return protoHack.has(Object.prototype);
-}
-`);
-    expect(results[0].result).toBe("false");
-  });
-
-  it("for-of on a Set instance iterates its recorded values", () => {
-    const results = runTest(`
-// @nudo:case "forof-values" ()
-function fn() {
-  const s = new Set([1, 2]);
-  const out = [];
-  for (const v of s) {
-    out.push(v);
-  }
-  return out;
-}
-`);
-    expect(results[0].result).toBe("[1, 2]");
-  });
-
-  it("Set.prototype.values.call(s) iterates like s.values()", () => {
-    const results = runTest(`
-// @nudo:case "proto-values-call" ()
-function fn() {
-  const s = new Set([1, 2]);
-  const out = [];
-  for (const v of Set.prototype.values.call(s)) {
-    out.push(v);
-  }
-  return out;
-}
-`);
-    expect(results[0].result).toBe("[1, 2]");
-  });
-
-  it("Set.delete() decides literally against recorded values and size stays number", () => {
-    const results = runTest(`
-// @nudo:case "delete-literal" ()
-function fn() {
-  const s = new Set([1, 2, 3]);
-  const hit = s.delete(2);
-  return [hit, s.size];
-}
-`);
-    expect(results[0].result).toBe("[true, number]");
-  });
-});