@nudojs/cli 0.2.1 → 0.3.1

package/src/__tests__/syntax-sugar.test.ts

@@ -1,345 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parse, extractDirectives, type CaseDirective } from "@nudojs/parser";
-import { typeValueToString, createEnvironment } 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("Syntax Sugar Tests", () => {
-  describe("Compound Assignment Operators", () => {
-    it("+=", () => {
-      const results = runTest(`
-// @nudo:case "add-assign" ([1, 2, 3, 4, 5])
-function sum(arr) {
-  let total = 0;
-  for (const n of arr) {
-    total += n;
-  }
-  return total;
-}
-`);
-      expect(results[0].result).toBe("15");
-    });
-
-    it("-=", () => {
-      const results = runTest(`
-// @nudo:case "sub-assign" (100, [10, 20, 30])
-function subtract(initial, values) {
-  let result = initial;
-  for (const v of values) {
-    result -= v;
-  }
-  return result;
-}
-`);
-      expect(results[0].result).toBe("40");
-    });
-
-    it("*=", () => {
-      const results = runTest(`
-// @nudo:case "mul-assign" ([2, 3, 4])
-function product(arr) {
-  let result = 1;
-  for (const n of arr) {
-    result *= n;
-  }
-  return result;
-}
-`);
-      expect(results[0].result).toBe("24");
-    });
-
-    it("/=", () => {
-      const results = runTest(`
-// @nudo:case "div-assign" (1000, [2, 5])
-function divide(initial, divisors) {
-  let result = initial;
-  for (const d of divisors) {
-    result /= d;
-  }
-  return result;
-}
-`);
-      expect(results[0].result).toBe("100");
-    });
-
-    it("%=", () => {
-      const results = runTest(`
-// @nudo:case "mod-assign" (17, [5, 3])
-function modChain(initial, divisors) {
-  let result = initial;
-  for (const d of divisors) {
-    result %= d;
-  }
-  return result;
-}
-`);
-      expect(results[0].result).toBe("2");
-    });
-
-    it("string +=", () => {
-      const results = runTest(`
-// @nudo:case "concat-assign" (["Hello", " ", "World"])
-function concat(parts) {
-  let result = "";
-  for (const part of parts) {
-    result += part;
-  }
-  return result;
-}
-`);
-      expect(results[0].result).toBe('"Hello World"');
-    });
-  });
-
-  describe("Object Method Shorthand", () => {
-    it("basic method shorthand", () => {
-      const results = runTest(`
-// @nudo:case "method" ()
-function createObj() {
-  return {
-    greet(name) {
-      return "Hello, " + name;
-    }
-  };
-}
-`);
-      expect(results[0].result).toContain("greet");
-    });
-
-    it("multiple methods", () => {
-      const results = runTest(`
-// @nudo:case "methods" ()
-function createCalculator() {
-  return {
-    add(a, b) { return a + b; },
-    subtract(a, b) { return a - b; },
-    multiply(a, b) { return a * b; }
-  };
-}
-`);
-      expect(results[0].result).toContain("add");
-      expect(results[0].result).toContain("subtract");
-      expect(results[0].result).toContain("multiply");
-    });
-
-    it("method with rest parameters", () => {
-      const results = runTest(`
-// @nudo:case "rest-params" ()
-function createLogger() {
-  return {
-    log(...args) {
-      return args;
-    }
-  };
-}
-`);
-      expect(results[0].result).toContain("log");
-    });
-
-    it("mixed properties and methods", () => {
-      const results = runTest(`
-// @nudo:case "mixed" ()
-function createService() {
-  return {
-    name: "MyService",
-    version: 1,
-    start() { return "started"; },
-    stop() { return "stopped"; }
-  };
-}
-`);
-      expect(results[0].result).toContain("name");
-      expect(results[0].result).toContain("version");
-      expect(results[0].result).toContain("start");
-      expect(results[0].result).toContain("stop");
-    });
-  });
-
-  describe("Async/Await Combinations", () => {
-    it("async function returning literal", () => {
-      const results = runTest(`
-// @nudo:case "async-literal" ()
-async function getValue() {
-  return 42;
-}
-`);
-      expect(results[0].result).toBe("Promise<42>");
-    });
-
-    it("async function returning Promise", () => {
-      const results = runTest(`
-// @nudo:case "async-promise" ()
-async function getValue() {
-  return Promise.resolve(42);
-}
-`);
-      expect(results[0].result).toBe("Promise<42>");
-    });
-
-    it("async function with await", () => {
-      const results = runTest(`
-// @nudo:case "async-await" ()
-async function getValue() {
-  const result = await Promise.resolve(42);
-  return result;
-}
-`);
-      expect(results[0].result).toBe("Promise<42>");
-    });
-
-    it("async function with try/catch", () => {
-      const results = runTest(`
-// @nudo:case "async-try-catch" ()
-async function safeOperation() {
-  try {
-    const result = await Promise.resolve("success");
-    return { success: true, data: result };
-  } catch (e) {
-    return { success: false, error: "failed" };
-  }
-}
-`);
-      expect(results[0].result).toContain("Promise");
-      expect(results[0].result).toContain("success");
-    });
-
-    it("async function with multiple awaits", () => {
-      const results = runTest(`
-// @nudo:case "async-multi-await" ()
-async function fetchAll() {
-  const a = await Promise.resolve(1);
-  const b = await Promise.resolve(2);
-  return [a, b];
-}
-`);
-      expect(results[0].result).toBe("Promise<[1, 2]>");
-    });
-  });
-
-  describe("Destructuring Patterns", () => {
-    it("object destructuring in parameters", () => {
-      const results = runTest(`
-// @nudo:case "destructure-obj" ({ name: "Alice", age: 30 })
-function greet({ name, age }) {
-  return name + " is " + age;
-}
-`);
-      expect(results[0].result).toBe('"Alice is 30"');
-    });
-
-    it("array destructuring in parameters", () => {
-      const results = runTest(`
-// @nudo:case "destructure-arr" ([1, 2, 3])
-function sum([a, b, c]) {
-  return a + b + c;
-}
-`);
-      expect(results[0].result).toBe("6");
-    });
-
-    it("nested destructuring", () => {
-      const results = runTest(`
-// @nudo:case "destructure-nested" ({ user: { name: "Alice", address: { city: "NYC" } } })
-function getCity({ user: { address: { city } } }) {
-  return city;
-}
-`);
-      expect(results[0].result).toBe('"NYC"');
-    });
-
-    it("destructuring with defaults", () => {
-      const results = runTest(`
-// @nudo:case "destructure-default" ({ name: "Alice" })
-function greet({ name, greeting = "Hello" }) {
-  return greeting + ", " + name;
-}
-`);
-      expect(results[0].result).toBe('"Hello, Alice"');
-    });
-  });
-
-  describe("Template Literals", () => {
-    it("basic template literal", () => {
-      const results = runTest(`
-// @nudo:case "template" ("World")
-function greet(name) {
-  return \`Hello, \${name}!\`;
-}
-`);
-      expect(results[0].result).toBe('"Hello, World!"');
-    });
-
-    it("template literal with expressions", () => {
-      const results = runTest(`
-// @nudo:case "template-expr" (2, 3)
-function calculate(a, b) {
-  return \`\${a} + \${b} = \${a + b}\`;
-}
-`);
-      expect(results[0].result).toBe('"2 + 3 = 5"');
-    });
-  });
-
-  describe("Optional Chaining", () => {
-    it("basic optional chaining", () => {
-      const results = runTest(`
-// @nudo:case "optional-chain" ({ user: { name: "Alice" } })
-function getName(obj) {
-  return obj?.user?.name;
-}
-`);
-      expect(results[0].result).toBe('"Alice"');
-    });
-
-    it("optional chaining with undefined", () => {
-      const results = runTest(`
-// @nudo:case "optional-undefined" ({})
-function getName(obj) {
-  return obj?.user?.name;
-}
-`);
-      expect(results[0].result).toBe("undefined");
-    });
-  });
-
-  describe("Nullish Coalescing", () => {
-    it("basic nullish coalescing", () => {
-      const results = runTest(`
-// @nudo:case "nullish" (null)
-function getValue(x) {
-  return x ?? "default";
-}
-`);
-      expect(results[0].result).toBe('"default"');
-    });
-
-    it("nullish with defined value", () => {
-      const results = runTest(`
-// @nudo:case "nullish-defined" ("hello")
-function getValue(x) {
-  return x ?? "default";
-}
-`);
-      expect(results[0].result).toBe('"hello"');
-    });
-  });
-});

package/src/builtins/builtin-intl.ts

@@ -1,17 +0,0 @@
-import { type TypeValue, T } from "@nudojs/core";
-
-export const INTL_DATETIMEFORMAT_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  format: () => T.string,
-};
-
-export const INTL_NUMBERFORMAT_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  format: () => T.string,
-};
-
-export function createDateTimeFormatType(): TypeValue {
-  return T.instanceOf("DateTimeFormat", {});
-}
-
-export function createNumberFormatType(): TypeValue {
-  return T.instanceOf("NumberFormat", {});
-}

package/src/builtins/builtin-map.ts

@@ -1,174 +0,0 @@
-import { type TypeValue, T, simplifyUnion, typeValueEquals } from "@nudojs/core";
-
-// Literal/instance keys recorded at construction (`new Map([['k', v]])`) or
-// via set() — precise enough for typeValueEquals lookup. Symbolic keys are
-// skipped: they cannot be definitely matched, so get() falls back to the
-// V | undefined approximation.
-export type MapEntry = { key: TypeValue; value: TypeValue };
-
-function entryKeyTrackable(key: TypeValue | undefined): boolean {
-  return key?.kind === "literal" || key?.kind === "instance";
-}
-
-// Union keys distribute: every member hitting → union of values, every
-// member missing → undefined, mixed → values | undefined.
-function lookupEntries(entries: MapEntry[], key: TypeValue): TypeValue | null {
-  if (key.kind === "union") {
-    const results = key.members.map((m) => lookupEntries(entries, m));
-    if (results.some((r) => r === null)) return null;
-    return simplifyUnion(results as TypeValue[]);
-  }
-  if (!entryKeyTrackable(key)) return null;
-  const hit = entries.find((e) => typeValueEquals(e.key, key));
-  return hit ? hit.value : T.undefined;
-}
-
-export const MAP_INSTANCE_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  get: (key: TypeValue, map?: TypeValue) => {
-    const entries = exactMapEntries(map);
-    if (entries) {
-      const looked = lookupEntries(entries, key);
-      if (looked !== null) return looked;
-    }
-    const typeArgs = (map as any)?._typeArgs;
-    if (typeArgs?.V) return T.union(typeArgs.V, T.undefined);
-    // Untyped receiver (unknown / non-Map value reaching the impl): a
-    // definite undefined would be a false claim and poison downstream
-    // guards (hoek isDeepEqual's `ref.name` path) into error-severity
-    // misses. Unknown keeps it honest.
-    return T.unknown;
-  },
-  set: (key: TypeValue, value: TypeValue, map?: TypeValue) => {
-    if (map) {
-      const typeArgs = (map as any)._typeArgs || { K: T.unknown, V: T.unknown };
-      (map as any)._typeArgs = {
-        K: typeArgs.K.kind === "unknown" ? key : simplifyUnion([typeArgs.K, key]),
-        V: typeArgs.V.kind === "unknown" ? value : simplifyUnion([typeArgs.V, value]),
-      };
-      if (entryKeyTrackable(key)) {
-        // An exact entry list can start on the first trackable set()
-        // (nothing untracked came before); once partial it stays partial.
-        if ((map as any)._entries === undefined && (map as any)._entriesExact !== false) {
-          (map as any)._entries = [];
-          (map as any)._entriesExact = true;
-        }
-        if ((map as any)._entriesExact) {
-          const entries = (map as any)._entries as MapEntry[];
-          const hit = entries.find((e) => typeValueEquals(e.key, key));
-          if (hit) hit.value = value;
-          else entries.push({ key, value });
-        }
-      } else {
-        (map as any)._entriesExact = false;
-      }
-    }
-    return map ?? T.unknown;
-  },
-  has: (key: TypeValue, map?: TypeValue) => {
-    const entries = exactMapEntries(map);
-    if (entries && entryKeyTrackable(key)) {
-      return T.literal(entries.some((e) => typeValueEquals(e.key, key)));
-    }
-    return T.boolean;
-  },
-  delete: (key: TypeValue, map?: TypeValue) => {
-    const entries = exactMapEntries(map);
-    if (entries && entryKeyTrackable(key)) {
-      const idx = entries.findIndex((e) => typeValueEquals(e.key, key));
-      if (idx >= 0) {
-        entries.splice(idx, 1);
-        return T.literal(true);
-      }
-      return T.literal(false);
-    }
-    return T.boolean;
-  },
-  clear: (value?: TypeValue, map?: TypeValue) => {
-    // m.clear() arrives as clear(receiver): the map sits in the first
-    // param slot when the call has no arguments.
-    const target = map ?? value;
-    if (target && (target as any)._entriesExact) {
-      (target as any)._entries = [];
-    }
-    return T.undefined;
-  },
-  forEach: () => T.undefined,
-  keys: (map?: TypeValue) => {
-    const entries = exactMapEntries(map);
-    if (entries) return T.tuple(entries.map((e) => e.key));
-    const typeArgs = (map as any)?._typeArgs;
-    if (typeArgs?.K) return T.array(typeArgs.K);
-    return T.array(T.unknown);
-  },
-  values: (map?: TypeValue) => {
-    const entries = exactMapEntries(map);
-    if (entries) return T.tuple(entries.map((e) => e.value));
-    const typeArgs = (map as any)?._typeArgs;
-    if (typeArgs?.V) return T.array(typeArgs.V);
-    return T.array(T.unknown);
-  },
-  entries: (map?: TypeValue) => mapEntriesIterable(map),
-};
-
-// Exact entry side table: present only when every key seen so far
-// (construction pairs + set() calls) was trackable. Partial tables must
-// not decide get()/has()/delete()/iteration — an untracked key could map
-// to anything.
-export function exactMapEntries(map: TypeValue | undefined): MapEntry[] | undefined {
-  if (!map || (map as any)._entriesExact !== true) return undefined;
-  return (map as any)._entries as MapEntry[] | undefined;
-}
-
-// entries() keeps feeding for-of destructuring (`for (const [k, v] of m)`)
-// and `new Map(...)` consumers: a tuple of [key, value] pairs when the
-// side table is complete, else Array<[K, V]>.
-export function mapEntriesIterable(map: TypeValue | undefined): TypeValue {
-  const entries = exactMapEntries(map);
-  if (entries) return T.tuple(entries.map((e) => T.tuple([e.key, e.value])));
-  const typeArgs = (map as any)?._typeArgs;
-  if (typeArgs?.K && typeArgs?.V) return T.array(T.tuple([typeArgs.K, typeArgs.V]));
-  return T.array(T.tuple([T.unknown, T.unknown]));
-}
-
-export function createMapType(args?: TypeValue[]): TypeValue {
-  const obj = T.instanceOf("Map", {});
-
-  if (args && args.length > 0) {
-    const arg = args[0];
-    if (arg.kind === "tuple" || arg.kind === "array") {
-      const elements = arg.kind === "tuple" ? arg.elements : [arg.element];
-      const keys: TypeValue[] = [];
-      const values: TypeValue[] = [];
-      const entries: MapEntry[] = [];
-      let exact = true;
-      for (const el of elements) {
-        if (el.kind === "tuple" && el.elements.length >= 2) {
-          keys.push(el.elements[0]);
-          values.push(el.elements[1]);
-          if (entryKeyTrackable(el.elements[0])) {
-            entries.push({ key: el.elements[0], value: el.elements[1] });
-          } else {
-            exact = false;
-          }
-        }
-      }
-      if (keys.length > 0) {
-        (obj as any)._typeArgs = { K: simplifyUnion(keys), V: simplifyUnion(values) };
-      }
-      // Only a fully trackable key list is exact: symbolic keys mean the
-      // recorded entries are a subset of the real ones.
-      if (exact && entries.length > 0) {
-        (obj as any)._entries = entries;
-        (obj as any)._entriesExact = true;
-      } else if (!exact) {
-        (obj as any)._entriesExact = false;
-      }
-    }
-  }
-
-  if (!(obj as any)._typeArgs) {
-    (obj as any)._typeArgs = { K: T.unknown, V: T.unknown };
-  }
-
-  return obj;
-}

package/src/builtins/builtin-promise.ts

@@ -1,116 +0,0 @@
-import { type TypeValue, T, simplifyUnion } from "@nudojs/core";
-
-export const PROMISE_STATIC_METHODS: Record<string, TypeValue> = {
-  resolve: T.unknown,
-  reject: T.never,
-  all: T.unknown,
-  race: T.unknown,
-  allSettled: T.unknown,
-  any: T.unknown,
-};
-
-export function evaluatePromiseStaticMethod(
-  methodName: string,
-  args: TypeValue[],
-): TypeValue | null {
-  if (methodName === "resolve") {
-    if (args.length > 0) return T.promise(args[0]);
-    return T.promise(T.undefined);
-  }
-
-  if (methodName === "reject") {
-    return T.promise(T.never);
-  }
-
-  if (methodName === "all") {
-    if (args.length > 0 && args[0].kind === "tuple") {
-      const elemTypes = args[0].elements.map((e: TypeValue) => {
-        if (e.kind === "promise") return e.value;
-        return T.unknown;
-      });
-      return T.promise(T.tuple(elemTypes));
-    }
-    if (args.length > 0 && args[0].kind === "array") {
-      return T.promise(T.array(args[0].element));
-    }
-    return T.promise(T.array(T.unknown));
-  }
-
-  if (methodName === "race") {
-    if (args.length > 0 && args[0].kind === "tuple") {
-      const elemTypes = args[0].elements.map((e: TypeValue) => {
-        if (e.kind === "promise") return e.value;
-        return T.unknown;
-      });
-      return T.promise(simplifyUnion(elemTypes));
-    }
-    if (args.length > 0 && args[0].kind === "array") {
-      const el = args[0].element;
-      return T.promise(el.kind === "promise" ? el.value : T.unknown);
-    }
-    return T.promise(T.unknown);
-  }
-
-  if (methodName === "allSettled") {
-    // Best effort: each slot settles to { status, value } — the fulfilled
-    // value is the element's promise payload (unknown for non-promises).
-    const settledOf = (e: TypeValue): TypeValue =>
-      T.object({
-        status: T.union(T.literal("fulfilled"), T.literal("rejected")),
-        value: e.kind === "promise" ? e.value : T.unknown,
-      });
-    if (args.length > 0 && args[0].kind === "tuple") {
-      return T.promise(T.tuple(args[0].elements.map(settledOf)));
-    }
-    if (args.length > 0 && args[0].kind === "array") {
-      return T.promise(T.array(settledOf(args[0].element)));
-    }
-    return T.promise(T.array(T.unknown));
-  }
-
-  if (methodName === "any") {
-    if (args.length > 0 && args[0].kind === "tuple") {
-      const elemTypes = args[0].elements.map((e: TypeValue) => {
-        if (e.kind === "promise") return e.value;
-        return T.unknown;
-      });
-      return T.promise(simplifyUnion(elemTypes));
-    }
-    if (args.length > 0 && args[0].kind === "array") {
-      const el = args[0].element;
-      return T.promise(el.kind === "promise" ? el.value : T.unknown);
-    }
-    return T.promise(T.unknown);
-  }
-
-  return null;
-}
-
-export function evaluatePromiseInstanceMethod(
-  promiseValue: TypeValue,
-  methodName: string,
-  args: TypeValue[],
-): TypeValue | null {
-  if (methodName === "then") {
-    if (promiseValue.kind === "promise") {
-      // A real function callback is executed by the evaluator's main call
-      // path (applyPromiseThenCallback) before reaching here; only
-      // non-callable handlers fall through to an unresolved value type.
-      return T.promise(T.unknown);
-    }
-  }
-
-  if (methodName === "catch") {
-    if (promiseValue.kind === "promise") {
-      return promiseValue; // catch returns same promise type
-    }
-  }
-
-  if (methodName === "finally") {
-    if (promiseValue.kind === "promise") {
-      return promiseValue; // finally returns same promise type
-    }
-  }
-
-  return null;
-}

package/src/builtins/builtin-reflect.ts

@@ -1,30 +0,0 @@
-import { type TypeValue, T } from "@nudojs/core";
-
-export const REFLECT_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  has: () => T.boolean,
-  get: () => T.unknown,
-  set: () => T.boolean,
-  deleteProperty: () => T.boolean,
-  apply: () => T.unknown,
-  construct: () => T.object({}),
-  // Shape-aware like Object.keys: known receivers list their declared
-  // own-property names (hoek's Utils.keys → clone/flatten key loops then
-  // iterate concrete keys instead of a symbolic string), arrays add the
-  // non-enumerable "length" own key. Unknown shapes keep the approximation.
-  ownKeys: (target?: TypeValue) => {
-    let base = target;
-    while (base?.kind === "refined") base = base.base;
-    if (base && (base.kind === "object" || base.kind === "instance")) {
-      return T.tuple(Object.keys(base.properties).map((k) => T.literal(k)));
-    }
-    if (base?.kind === "tuple") {
-      return T.tuple([
-        ...base.elements.map((_, i) => T.literal(String(i))),
-        T.literal("length"),
-      ]);
-    }
-    return T.array(T.string);
-  },
-  getPrototypeOf: () => T.union(T.object({}), T.null),
-  getOwnPropertyDescriptor: () => T.union(T.object({}), T.undefined),
-};