@nudojs/core 0.3.0 → 0.4.0

package/src/algebra/__tests__/exec-bpath.test.ts

@@ -1,193 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  $add,
-  $lt,
-  $lit,
-  $fork,
-  $for,
-  $forIter,
-  $obj,
-  $get,
-  $set,
-  $while,
-  $whileSeq,
-  num,
-  numVar,
-  litValue,
-  absToString,
-  transpile,
-} from "@nudojs/core";
-
-describe("B-path runtime ops", () => {
-  it("add(lit, lit) stays exact literal", () => {
-    const r = $add($lit(1), $lit(3));
-    expect(litValue(r)).toBe(4);
-  });
-
-  it("add(number, lit) is number", () => {
-    const r = $add(num(), $lit(1));
-    expect(r.shape.k).toBe("prim");
-    if (r.shape.k === "prim") expect(r.shape.type).toBe("number");
-  });
-
-  it("add(var, lit) keeps term identity", () => {
-    const r = $add(numVar("x"), $lit(1));
-    expect(r.term?.op).toBe("app");
-  });
-});
-
-describe("B-path $fork", () => {
-  it("literal true takes consequent only", () => {
-    const r = $fork($lit(true), () => $lit(1), () => $lit(2));
-    expect(litValue(r)).toBe(1);
-  });
-
-  it("literal false takes alternate only", () => {
-    const r = $fork($lit(false), () => $lit(1), () => $lit(2));
-    expect(litValue(r)).toBe(2);
-  });
-
-  it("abstract boolean joins both branches", () => {
-    const cond = {
-      shape: { k: "prim" as const, type: "boolean" as const },
-      conf: "exact" as const,
-    };
-    const r = $fork(cond, () => $lit(1), () => $lit(2));
-    expect(litValue(r)).toBeUndefined();
-  });
-});
-
-describe("B-path $for (bounded)", () => {
-  it("concrete trip count: i goes 0→3", () => {
-    const r = $for(
-      $lit(0),
-      (s) => $lt(s, $lit(3)),
-      (s) => $add(s, $lit(1)),
-      (s) => s,
-      8,
-    );
-    expect(litValue(r)).toBe(3);
-  });
-
-  it("abstract bound terminates within budget", () => {
-    const n = num();
-    const r = $for(
-      $lit(0),
-      (s) => $lt(s, n),
-      (s) => $add(s, $lit(1)),
-      (s) => s,
-      4,
-    );
-    expect(r).toBeDefined();
-    expect(r.conf).not.toBe("opaque");
-  });
-
-  it("generator yields at most maxIters", () => {
-    const states = [
-      ...$forIter(
-        $lit(0),
-        () => $lit(true),
-        (s) => $add(s, $lit(1)),
-        (s) => s,
-        5,
-      ),
-    ];
-    expect(states.length).toBe(5);
-  });
-});
-
-describe("B-path objects", () => {
-  it("$get reads slots; miss is undefined", () => {
-    const o = $obj({ id: $lit(1), name: $lit("Ada") });
-    expect(litValue($get(o, "id"))).toBe(1);
-    expect(litValue($get(o, "name"))).toBe("Ada");
-    expect(litValue($get(o, "missing"))).toBeUndefined();
-    expect(absToString($get(o, "missing"))).toContain("undefined");
-  });
-
-  it("$set returns new object with updated slot", () => {
-    const o = $obj({ id: $lit(1) });
-    const o2 = $set(o, "id", $lit(2));
-    expect(litValue($get(o, "id"))).toBe(1);
-    expect(litValue($get(o2, "id"))).toBe(2);
-  });
-});
-
-describe("B-path $while", () => {
-  it("concrete countdown", () => {
-    const r = $while(
-      $obj({ i: $lit(3), acc: $lit(0) }),
-      (s) => $lt($lit(0), $get(s, "i")),
-      (s) => $set($set(s, "acc", $add($get(s, "acc"), $get(s, "i"))), "i", $lit(0)),
-      8,
-    );
-    // i>0 false immediately after first step sets i=0... actually first test 0<3 true
-    // step: acc=0+3=3, i=0 → next test 0<0 false → exit  {i:0, acc:3}
-    expect(litValue($get(r, "acc"))).toBe(3);
-  });
-
-  it("$whileSeq runs body while test true", () => {
-    let i = $lit(0);
-    const hits: number[] = [];
-    $whileSeq(
-      () => $lt(i, $lit(3)),
-      () => {
-        hits.push(litValue(i) as number);
-        i = $add(i, $lit(1));
-      },
-      8,
-    );
-    expect(hits).toEqual([0, 1, 2]);
-    expect(litValue(i)).toBe(3);
-  });
-});
-
-describe("B-path transpile", () => {
-  it("rewrites + to $add", () => {
-    const out = transpile(`function add(a, b) { return a + b; }`, {
-      runtimeImport: "@nudojs/core/exec",
-    });
-    expect(out).toContain("$add(a, b)");
-    expect(out).not.toMatch(/return a \+ b/);
-  });
-
-  it("rewrites if to $fork", () => {
-    const out = transpile(`function f(x) { if (x > 0) { return 1; } return 2; }`, {
-      runtimeImport: "@nudojs/core/exec",
-    });
-    expect(out).toContain("$fork(");
-    expect(out).toContain("$gt(");
-  });
-
-  it("emits $for for classic counting loops", () => {
-    const out = transpile(
-      `function sum(n) { let i = 0; for (let i = 0; i < n; i = i + 1) {} return i; }`,
-      { runtimeImport: "@nudojs/core/exec", maxLoopIters: 4 },
-    );
-    expect(out).toContain("$for(");
-  });
-
-  it("rewrites object literal and member access", () => {
-    const out = transpile(
-      `function make() { const o = { id: 1, name: "x" }; return o.id; }`,
-      { runtimeImport: "@nudojs/core/exec" },
-    );
-    expect(out).toContain("$obj(");
-    expect(out).toContain('$get(o, "id")');
-  });
-
-  it("rewrites while to $whileSeq", () => {
-    const out = transpile(
-      `function f(n) { let i = 0; while (i < n) { i = i + 1; } return i; }`,
-      { runtimeImport: "@nudojs/core/exec", maxLoopIters: 5 },
-    );
-    expect(out).toContain("$whileSeq(");
-  });
-
-  it("rewrites obj.field = v to $set", () => {
-    const out = transpile(`function f() { const o = { a: 1 }; o.a = 2; return o; }`, {
-      runtimeImport: "@nudojs/core/exec",
-    });
-    expect(out).toContain("$set(");
-  });
-});

package/src/algebra/__tests__/exec-class.test.ts

@@ -1,56 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  runTranspiled,
-  callTranspiledExportFull,
-  $lit,
-  litValue,
-  absToString,
-} from "@nudojs/core";
-
-describe("B-path class / this", () => {
-  it("constructor writes fields; method reads this", () => {
-    const src = `
-class Point {
-  constructor(x, y) {
-    this.x = x;
-    this.y = y;
-  }
-  sum() {
-    return this.x + this.y;
-  }
-}
-export function go() {
-  const p = new Point(1, 2);
-  return p.sum();
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(3);
-    expect(absToString(r.result)).toContain("3");
-  });
-
-  it("new + field access", () => {
-    const src = `
-class Box {
-  constructor(v) { this.v = v; }
-}
-export function get() {
-  const b = new Box(9);
-  return b.v;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "get", []);
-    expect(litValue(r.result)).toBe(9);
-  });
-
-  it("transpiles class to $class", async () => {
-    const { transpile } = await import("@nudojs/core");
-    const out = transpile(`class A { constructor(x) { this.x = x; } m() { return this.x; } }
-export function go() { const a = new A(1); return a.m(); }`);
-    expect(out).toContain("$class(");
-    expect(out).toContain("$new(");
-    expect(out).toContain("$invoke(");
-  });
-});

package/src/algebra/__tests__/exec-e2e.test.ts

@@ -1,97 +0,0 @@
-import { describe, it, expect, afterAll } from "vitest";
-import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, dirname } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { transpile, litValue, absToString, $lit, $arr, $idx, $len, $get, $obj } from "@nudojs/core";
-
-const dirs: string[] = [];
-afterAll(() => {
-  for (const d of dirs) rmSync(d, { recursive: true, force: true });
-});
-
-const runtimeUrl = pathToFileURL(
-  join(dirname(fileURLToPath(import.meta.url)), "../exec/runtime.ts"),
-).href;
-
-/** transpile 后写盘并动态 import（真 Node 执行 B 路径程序） */
-async function execTranspiled(source: string, exportName: string) {
-  const dir = mkdtempSync(join(tmpdir(), "nudo-bpath-e2e-"));
-  dirs.push(dir);
-  // 指向 monorepo 内 runtime，vitest/node 均可解析 .ts
-  const js = transpile(source, { runtimeImport: runtimeUrl });
-  const modPath = join(dir, "mod.mjs");
-  writeFileSync(modPath, js, "utf-8");
-  const mod = await import(pathToFileURL(modPath).href);
-  return mod[exportName] as (...args: unknown[]) => unknown;
-}
-
-describe("B-path e2e (transpile + Node import)", () => {
-  it("add executes on Abs literals", async () => {
-    const add = await execTranspiled(
-      `export function add(a, b) { return a + b; }`,
-      "add",
-    );
-    const r = add($lit(2), $lit(40)) as ReturnType<typeof $lit>;
-    expect(litValue(r)).toBe(42);
-  });
-
-  it("array literal + index + length", async () => {
-    const run = await execTranspiled(
-      `export function run() {
-  const a = [1, 2, 3];
-  const x = a[1];
-  const n = a.length;
-  return x + n;
-}`,
-      "run",
-    );
-    const r = run() as ReturnType<typeof $lit>;
-    expect(litValue(r)).toBe(5); // 2 + 3
-  });
-
-  it("object destructure + member", async () => {
-    const run = await execTranspiled(
-      `export function run() {
-  const o = { id: 10, name: "a" };
-  const { id, name } = o;
-  return id + name;
-}`,
-      "run",
-    );
-    const r = run() as ReturnType<typeof $lit>;
-    expect(absToString(r)).toContain("string"); // 10 + "a" → "10a"
-    expect(litValue(r)).toBe("10a");
-  });
-
-  it("array destructure", async () => {
-    const run = await execTranspiled(
-      `export function run() {
-  const pair = [3, 4];
-  const [x, y] = pair;
-  return x * y;
-}`,
-      "run",
-    );
-    const r = run() as ReturnType<typeof $lit>;
-    expect(litValue(r)).toBe(12);
-  });
-
-  it("local function call + if/else", async () => {
-    const go = await execTranspiled(
-      `export function go(n) {
-  if (n > 0) { return n + 1; } else { return 0; }
-}`,
-      "go",
-    );
-    expect(litValue(go($lit(1)) as never)).toBe(2);
-    expect(litValue(go($lit(-1)) as never)).toBe(0);
-  });
-
-  it("runtime array helpers", () => {
-    const a = $arr([$lit(1), $lit(2)]);
-    expect(litValue($idx(a, $lit(0)))).toBe(1);
-    expect(litValue($len(a))).toBe(2);
-    expect(litValue($get($obj({ k: $lit(1) }), "k"))).toBe(1);
-  });
-});

package/src/algebra/__tests__/exec-generator.test.ts

@@ -1,53 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  runTranspiled,
-  callTranspiledExportFull,
-  $lit,
-  litValue,
-  absToString,
-  transpile,
-} from "@nudojs/core";
-
-describe("B-path generators", () => {
-  it("function* collects yields into tuple", () => {
-    const src = `
-export function* gen() {
-  yield 1;
-  yield 2;
-  yield 3;
-}
-export function go() {
-  const xs = gen();
-  return xs[0] + xs[1] + xs[2];
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(6);
-  });
-
-  it("for-of over generator", () => {
-    const src = `
-export function* nums() {
-  yield 1;
-  yield 2;
-}
-export function sum() {
-  let t = 0;
-  for (const x of nums()) {
-    t = t + x;
-  }
-  return t;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "sum", []);
-    expect(litValue(r.result)).toBe(3);
-  });
-
-  it("transpiles generator to $gen/$yield", () => {
-    const out = transpile(`export function* g() { yield 1; }`);
-    expect(out).toContain("$gen(");
-    expect(out).toContain("$yield(");
-  });
-});

package/src/algebra/__tests__/exec-inherit-default.test.ts

@@ -1,111 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  runTranspiled,
-  callTranspiledExportFull,
-  $lit,
-  $await,
-  litValue,
-  absToString,
-} from "@nudojs/core";
-
-describe("B-path inheritance / super", () => {
-  it("child inherits parent method", () => {
-    const src = `
-class Base {
-  constructor(x) { this.x = x; }
-  get() { return this.x; }
-}
-class Child extends Base {
-  double() { return this.get() + this.get(); }
-}
-export function go() {
-  const c = new Child(5);
-  return c.double();
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(10);
-  });
-
-  it("super() runs parent ctor", () => {
-    const src = `
-class Base {
-  constructor(x) { this.x = x; }
-}
-class Child extends Base {
-  constructor(x, y) {
-    super(x);
-    this.y = y;
-  }
-  sum() { return this.x + this.y; }
-}
-export function go() {
-  const c = new Child(1, 2);
-  return c.sum();
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(3);
-  });
-
-  it("super.method() calls parent implementation", () => {
-    const src = `
-class Base {
-  hello() { return "base"; }
-}
-class Child extends Base {
-  hello() { return super.hello() + "+child"; }
-}
-export function go() {
-  const c = new Child();
-  return c.hello();
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe("base+child");
-  });
-});
-
-describe("B-path destructure defaults", () => {
-  it("object default fills undefined", () => {
-    const src = `
-export function go() {
-  const o = { a: 1 };
-  const { a, b = 99 } = o;
-  return a + b;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(100);
-  });
-
-  it("object present value wins over default", () => {
-    const src = `
-export function go() {
-  const o = { a: 5 };
-  const { a = 1 } = o;
-  return a;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(5);
-  });
-
-  it("array default fills out-of-range", () => {
-    const src = `
-export function go() {
-  const xs = [1];
-  const [a, b = 7] = xs;
-  return a + b;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(8);
-  });
-});

package/src/algebra/__tests__/exec-optional-nested.test.ts

@@ -1,87 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  runTranspiled,
-  callTranspiledExportFull,
-  $lit,
-  $obj,
-  $arr,
-  litValue,
-  absToString,
-  transpile,
-} from "@nudojs/core";
-
-describe("B-path optional chaining", () => {
-  it("a?.b short-circuits on nullish", () => {
-    const src = `
-export function go(o) {
-  return o?.id;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const ok = callTranspiledExportFull(exports, "go", [$obj({ id: $lit(7) })]);
-    expect(litValue(ok.result)).toBe(7);
-    const nil = callTranspiledExportFull(exports, "go", [$lit(null)]);
-    expect(litValue(nil.result)).toBeUndefined();
-  });
-
-  it("a?.b.c chains", () => {
-    const src = `
-export function go(o) {
-  return o?.user?.name;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const ok = callTranspiledExportFull(exports, "go", [
-      $obj({ user: $obj({ name: $lit("Ada") }) }),
-    ]);
-    expect(litValue(ok.result)).toBe("Ada");
-    const nil = callTranspiledExportFull(exports, "go", [$lit(null)]);
-    expect(litValue(nil.result)).toBeUndefined();
-  });
-
-  it("transpiles optional member", () => {
-    const out = transpile(`export function f(o) { return o?.x; }`);
-    expect(out).toContain("$optionalGet(");
-  });
-});
-
-describe("B-path nested destructure", () => {
-  it("nested object pattern", () => {
-    const src = `
-export function go() {
-  const o = { a: { b: 3 } };
-  const { a: { b } } = o;
-  return b;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(3);
-  });
-
-  it("nested with default", () => {
-    const src = `
-export function go() {
-  const o = { a: {} };
-  const { a: { b = 9 } } = o;
-  return b;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(9);
-  });
-
-  it("array of objects", () => {
-    const src = `
-export function go() {
-  const xs = [{ v: 4 }];
-  const [{ v }] = xs;
-  return v;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const r = callTranspiledExportFull(exports, "go", []);
-    expect(litValue(r.result)).toBe(4);
-  });
-});

package/src/algebra/__tests__/exec-rest.test.ts

@@ -1,55 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  runTranspiled,
-  callTranspiledExportFull,
-  $lit,
-  $arr,
-  litValue,
-} from "@nudojs/core";
-import { isBPathCapable } from "@nudojs/service";
-
-describe("B-path rest parameters", () => {
-  it("collects rest into $arr", () => {
-    const src = `
-export function sum(a, ...rest) {
-  let t = a;
-  let i = 0;
-  while (i < rest.length) {
-    t = t + rest[i];
-    i = i + 1;
-  }
-  return t;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const sum = exports.sum as (...a: unknown[]) => unknown;
-    // named args then rest as separate args — callTranspiledExport only spreads args
-    // Our convention: call with named + rest items as extra args via Function arguments
-    const r = sum($lit(1), $lit(2), $lit(3));
-    expect(litValue(r as never)).toBe(6);
-  });
-
-  it("rest empty when only named args", () => {
-    const src = `
-export function first(a, ...rest) {
-  return a;
-}
-export function restLen(a, ...rest) {
-  return rest.length;
-}
-`;
-    const exports = runTranspiled(src, { mode: "analyze" });
-    const first = exports.first as (...a: unknown[]) => unknown;
-    const restLen = exports.restLen as (...a: unknown[]) => unknown;
-    expect(litValue(first($lit(9)) as never)).toBe(9);
-    expect(litValue(restLen($lit(9)) as never)).toBe(0);
-    expect(litValue(restLen($lit(9), $lit(1), $lit(2)) as never)).toBe(2);
-  });
-});
-
-describe("B-primary capable files", () => {
-  it("isBPathCapable allows require now", () => {
-    expect(isBPathCapable("function f(x) { return x + 1; }")).toBe(true);
-    expect(isBPathCapable("const x = require('y');")).toBe(true);
-  });
-});