@nudojs/core 0.3.0 → 0.4.0

package/src/__tests__/type-value-refined.test.ts

@@ -1,210 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  T,
-  typeValueEquals,
-  isSubtypeOf,
-  typeValueToString,
-  deepCloneTypeValue,
-  getPrimitiveTypeOf,
-  getRefinedBase,
-} from "../type-value.ts";
-import { createTemplate, isTemplate, getTemplateParts, getKnownPrefix, getKnownSuffix } from "../refinements/template.ts";
-import { createRange, isRange, getRangeMeta } from "../refinements/range.ts";
-
-describe("Refined TypeValue", () => {
-  describe("T.refine", () => {
-    it("creates a refined type", () => {
-      const odd = T.refine(T.number, { name: "odd", meta: {} });
-      expect(odd.kind).toBe("refined");
-      if (odd.kind === "refined") {
-        expect(odd.base).toBe(T.number);
-        expect(odd.refinement.name).toBe("odd");
-      }
-    });
-  });
-
-  describe("typeValueEquals", () => {
-    it("equal refined types with same name and base", () => {
-      const a = T.refine(T.number, { name: "odd", meta: {} });
-      const b = T.refine(T.number, { name: "odd", meta: {} });
-      expect(typeValueEquals(a, b)).toBe(true);
-    });
-
-    it("different name means not equal", () => {
-      const a = T.refine(T.number, { name: "odd", meta: {} });
-      const b = T.refine(T.number, { name: "even", meta: {} });
-      expect(typeValueEquals(a, b)).toBe(false);
-    });
-
-    it("different base means not equal", () => {
-      const a = T.refine(T.number, { name: "x", meta: {} });
-      const b = T.refine(T.string, { name: "x", meta: {} });
-      expect(typeValueEquals(a, b)).toBe(false);
-    });
-  });
-
-  describe("isSubtypeOf", () => {
-    it("refined is subtype of its base", () => {
-      const odd = T.refine(T.number, { name: "odd", meta: {} });
-      expect(isSubtypeOf(odd, T.number)).toBe(true);
-    });
-
-    it("refined is subtype of unknown", () => {
-      const odd = T.refine(T.number, { name: "odd", meta: {} });
-      expect(isSubtypeOf(odd, T.unknown)).toBe(true);
-    });
-
-    it("literal is subtype of refined when check passes", () => {
-      const odd = T.refine(T.number, {
-        name: "odd",
-        meta: {},
-        check: (v) => typeof v === "number" && v % 2 !== 0,
-      });
-      expect(isSubtypeOf(T.literal(3), odd)).toBe(true);
-      expect(isSubtypeOf(T.literal(4), odd)).toBe(false);
-    });
-
-    it("nested refined is subtype of outer base", () => {
-      const integer = T.refine(T.number, { name: "integer", meta: {} });
-      const positiveInt = T.refine(integer, { name: "positive integer", meta: {} });
-      expect(isSubtypeOf(positiveInt, T.number)).toBe(true);
-      expect(isSubtypeOf(positiveInt, integer)).toBe(true);
-    });
-  });
-
-  describe("typeValueToString", () => {
-    it("uses refinement name", () => {
-      const odd = T.refine(T.number, { name: "odd", meta: {} });
-      expect(typeValueToString(odd)).toBe("odd");
-    });
-  });
-
-  describe("getPrimitiveTypeOf", () => {
-    it("delegates to base", () => {
-      const odd = T.refine(T.number, { name: "odd", meta: {} });
-      expect(getPrimitiveTypeOf(odd)).toBe("number");
-    });
-
-    it("handles nested refined", () => {
-      const inner = T.refine(T.string, { name: "inner", meta: {} });
-      const outer = T.refine(inner, { name: "outer", meta: {} });
-      expect(getPrimitiveTypeOf(outer)).toBe("string");
-    });
-  });
-
-  describe("getRefinedBase", () => {
-    it("unwraps to primitive", () => {
-      const inner = T.refine(T.number, { name: "a", meta: {} });
-      const outer = T.refine(inner, { name: "b", meta: {} });
-      expect(getRefinedBase(outer)).toBe(T.number);
-    });
-
-    it("returns non-refined as-is", () => {
-      expect(getRefinedBase(T.string)).toBe(T.string);
-    });
-  });
-
-  describe("deepCloneTypeValue", () => {
-    it("clones refined type", () => {
-      const odd = T.refine(T.number, { name: "odd", meta: { x: 1 } });
-      const cloned = deepCloneTypeValue(odd);
-      expect(typeValueEquals(cloned, odd)).toBe(true);
-      expect(cloned).not.toBe(odd);
-    });
-  });
-});
-
-describe("Template String", () => {
-  it("creates template from parts", () => {
-    const tmpl = createTemplate([T.literal("xy"), T.string]);
-    expect(isTemplate(tmpl)).toBe(true);
-    expect(tmpl.kind).toBe("refined");
-  });
-
-  it("collapses to literal when all parts are literal", () => {
-    const tmpl = createTemplate([T.literal("hello"), T.literal(" world")]);
-    expect(tmpl.kind).toBe("literal");
-    if (tmpl.kind === "literal") expect(tmpl.value).toBe("hello world");
-  });
-
-  it("collapses to T.string when only T.string", () => {
-    const tmpl = createTemplate([T.string]);
-    expect(tmpl.kind).toBe("primitive");
-  });
-
-  it("getKnownPrefix extracts leading literals", () => {
-    expect(getKnownPrefix([T.literal("xy"), T.string])).toBe("xy");
-    expect(getKnownPrefix([T.string, T.literal("z")])).toBe("");
-    expect(getKnownPrefix([T.literal("a"), T.literal("b"), T.string])).toBe("ab");
-  });
-
-  it("getKnownSuffix extracts trailing literals", () => {
-    expect(getKnownSuffix([T.string, T.literal("!")])).toBe("!");
-    expect(getKnownSuffix([T.literal("x"), T.string])).toBe("");
-  });
-
-  it("getTemplateParts returns parts", () => {
-    const tmpl = createTemplate([T.literal("x"), T.string]);
-    const parts = getTemplateParts(tmpl);
-    expect(parts).toHaveLength(2);
-  });
-
-  it("toString formats as template literal", () => {
-    const tmpl = createTemplate([T.literal("xy"), T.string]);
-    expect(typeValueToString(tmpl)).toBe("`xy${string}`");
-  });
-
-  it("is subtype of T.string", () => {
-    const tmpl = createTemplate([T.literal("x"), T.string]);
-    expect(isSubtypeOf(tmpl, T.string)).toBe(true);
-  });
-
-  it("check validates concrete strings", () => {
-    const tmpl = createTemplate([T.literal("xy"), T.string]);
-    if (tmpl.kind === "refined" && tmpl.refinement.check) {
-      expect(tmpl.refinement.check("xyhello")).toBe(true);
-      expect(tmpl.refinement.check("xy")).toBe(true);
-      expect(tmpl.refinement.check("ahello")).toBe(false);
-    }
-  });
-});
-
-describe("Range", () => {
-  it("creates range type", () => {
-    const r = createRange({ min: 0 });
-    expect(isRange(r)).toBe(true);
-    expect(r.kind).toBe("refined");
-  });
-
-  it("collapses to literal when min === max", () => {
-    const r = createRange({ min: 5, max: 5 });
-    expect(r.kind).toBe("literal");
-    if (r.kind === "literal") expect(r.value).toBe(5);
-  });
-
-  it("getRangeMeta returns metadata", () => {
-    const r = createRange({ min: 0, max: 100, integer: true });
-    const meta = getRangeMeta(r);
-    expect(meta).toEqual({ min: 0, max: 100, integer: true });
-  });
-
-  it("is subtype of T.number", () => {
-    const r = createRange({ min: 0 });
-    expect(isSubtypeOf(r, T.number)).toBe(true);
-  });
-
-  it("toString formats with constraints", () => {
-    expect(typeValueToString(createRange({ min: 0 }))).toBe("number (>= 0)");
-    expect(typeValueToString(createRange({ min: 0, max: 100 }))).toBe("number (>= 0, <= 100)");
-    expect(typeValueToString(createRange({ integer: true }))).toBe("integer");
-  });
-
-  it("check validates concrete numbers", () => {
-    const r = createRange({ min: 0, max: 10 });
-    if (r.kind === "refined" && r.refinement.check) {
-      expect(r.refinement.check(5)).toBe(true);
-      expect(r.refinement.check(-1)).toBe(false);
-      expect(r.refinement.check(11)).toBe(false);
-    }
-  });
-});

package/src/__tests__/type-value.test.ts

@@ -1,319 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  T,
-  type LiteralValue,
-  type TypeValue,
-  typeValueEquals,
-  simplifyUnion,
-  widenLiteral,
-  collapseLiteralUnion,
-  isSubtypeOf,
-  typeValueToString,
-  narrowType,
-  subtractType,
-  getPrimitiveTypeOf,
-} from "../type-value.ts";
-import { createTemplate } from "../refinements/template.ts";
-
-describe("T factory", () => {
-  it("creates literal type values", () => {
-    expect(T.literal(1)).toEqual({ kind: "literal", value: 1 });
-    expect(T.literal("hello")).toEqual({ kind: "literal", value: "hello" });
-    expect(T.literal(true)).toEqual({ kind: "literal", value: true });
-    expect(T.literal(null)).toEqual({ kind: "literal", value: null });
-    expect(T.literal(undefined)).toEqual({ kind: "literal", value: undefined });
-  });
-
-  it("provides primitive singletons", () => {
-    expect(T.number).toEqual({ kind: "primitive", type: "number" });
-    expect(T.string).toEqual({ kind: "primitive", type: "string" });
-    expect(T.boolean).toEqual({ kind: "primitive", type: "boolean" });
-  });
-
-  it("creates object type values", () => {
-    const obj = T.object({ x: T.number, y: T.string });
-    expect(obj.kind).toBe("object");
-    if (obj.kind === "object") {
-      expect(obj.properties.x).toBe(T.number);
-      expect(obj.properties.y).toBe(T.string);
-      expect(typeof obj.id).toBe("symbol");
-    }
-  });
-
-  it("creates union type values with simplification", () => {
-    const u = T.union(T.literal(1), T.literal(2));
-    expect(u.kind).toBe("union");
-    if (u.kind === "union") {
-      expect(u.members).toHaveLength(2);
-    }
-  });
-
-  it("simplifies single-member union to the member", () => {
-    const u = T.union(T.number);
-    expect(u).toBe(T.number);
-  });
-
-  it("simplifies empty union to never", () => {
-    const u = T.union(T.never, T.never);
-    expect(u).toEqual(T.never);
-  });
-});
-
-describe("typeValueEquals", () => {
-  it("compares literals", () => {
-    expect(typeValueEquals(T.literal(1), T.literal(1))).toBe(true);
-    expect(typeValueEquals(T.literal(1), T.literal(2))).toBe(false);
-  });
-
-  it("compares primitives", () => {
-    expect(typeValueEquals(T.number, T.number)).toBe(true);
-    expect(typeValueEquals(T.number, T.string)).toBe(false);
-  });
-
-  it("compares never and unknown", () => {
-    expect(typeValueEquals(T.never, T.never)).toBe(true);
-    expect(typeValueEquals(T.unknown, T.unknown)).toBe(true);
-    expect(typeValueEquals(T.never, T.unknown)).toBe(false);
-  });
-});
-
-describe("simplifyUnion", () => {
-  it("deduplicates members", () => {
-    const result = simplifyUnion([T.literal(1), T.literal(1), T.literal(2)]);
-    expect(result.kind).toBe("union");
-    if (result.kind === "union") {
-      expect(result.members).toHaveLength(2);
-    }
-  });
-
-  it("flattens nested unions", () => {
-    const inner = T.union(T.literal(1), T.literal(2));
-    const result = simplifyUnion([inner, T.literal(3)]);
-    expect(result.kind).toBe("union");
-    if (result.kind === "union") {
-      expect(result.members).toHaveLength(3);
-    }
-  });
-
-  it("absorbs unknown", () => {
-    const result = simplifyUnion([T.number, T.unknown]);
-    expect(result).toEqual(T.unknown);
-  });
-
-  it("removes never", () => {
-    const result = simplifyUnion([T.number, T.never]);
-    expect(result).toBe(T.number);
-  });
-});
-
-describe("widenLiteral", () => {
-  it("widens number literal to number", () => {
-    expect(widenLiteral(T.literal(42))).toEqual(T.number);
-  });
-
-  it("widens string literal to string", () => {
-    expect(widenLiteral(T.literal("hi"))).toEqual(T.string);
-  });
-
-  it("widens boolean literal to boolean", () => {
-    expect(widenLiteral(T.literal(true))).toEqual(T.boolean);
-  });
-
-  it("returns non-literal unchanged", () => {
-    expect(widenLiteral(T.number)).toBe(T.number);
-  });
-
-  it("collapses 20 number literals beyond maxLiterals to number", () => {
-    const members = Array.from({ length: 20 }, (_, i) => T.literal((i + 1) ** 2));
-    const u = { kind: "union", members } as const;
-    const result = collapseLiteralUnion(u, 4);
-    expect(result).toEqual(T.number);
-  });
-
-  it("collapses 5 string literals to string", () => {
-    const u = {
-      kind: "union",
-      members: ["a", "b", "c", "d", "e"].map((s) => T.literal(s)),
-    } as const;
-    const result = collapseLiteralUnion(u, 4);
-    expect(result).toEqual(T.string);
-  });
-
-  it("returns union unchanged when member count equals maxLiterals", () => {
-    const u: TypeValue = {
-      kind: "union",
-      members: [T.literal(1), T.literal(2), T.literal(3), T.literal(4)],
-    };
-    expect(collapseLiteralUnion(u, 4)).toBe(u);
-  });
-
-  it("mixed union: number literals absorbed by T.number, string literal kept (行为已修复：吸收律)", () => {
-    const u: TypeValue = {
-      kind: "union",
-      members: [T.literal(1), T.number, T.literal("x"), T.literal(2), T.literal(3)],
-    };
-    // 原断言期望原样返回 u；现 collapseLiteralUnion 复用 simplifyUnion 的吸收律，
-    // 数字字面量 1/2/3 被共存的 T.number 吸收，仅剩 ["x", number]（数量 ≤ 阈值不再坍缩）
-    expect(collapseLiteralUnion(u, 4)).toEqual(T.union(T.number, T.literal("x")));
-  });
-
-  it("returns non-union unchanged (single literal / T.number)", () => {
-    const lit = T.literal(1);
-    expect(collapseLiteralUnion(lit, 0)).toBe(lit);
-    expect(collapseLiteralUnion(T.number, 0)).toBe(T.number);
-  });
-});
-
-describe("isSubtypeOf", () => {
-  it("everything is subtype of unknown", () => {
-    expect(isSubtypeOf(T.number, T.unknown)).toBe(true);
-    expect(isSubtypeOf(T.literal(1), T.unknown)).toBe(true);
-  });
-
-  it("never is subtype of everything", () => {
-    expect(isSubtypeOf(T.never, T.number)).toBe(true);
-    expect(isSubtypeOf(T.never, T.never)).toBe(true);
-  });
-
-  it("literal is subtype of its primitive", () => {
-    expect(isSubtypeOf(T.literal(1), T.number)).toBe(true);
-    expect(isSubtypeOf(T.literal("hi"), T.string)).toBe(true);
-    expect(isSubtypeOf(T.literal(true), T.boolean)).toBe(true);
-  });
-
-  it("literal is not subtype of wrong primitive", () => {
-    expect(isSubtypeOf(T.literal(1), T.string)).toBe(false);
-  });
-
-  it("union is subtype if all members are", () => {
-    const u = T.union(T.literal(1), T.literal(2));
-    expect(isSubtypeOf(u, T.number)).toBe(true);
-  });
-
-  it("value is subtype of union containing it", () => {
-    const u = T.union(T.number, T.string);
-    expect(isSubtypeOf(T.number, u)).toBe(true);
-  });
-});
-
-describe("typeValueToString", () => {
-  it("formats literals", () => {
-    expect(typeValueToString(T.literal(1))).toBe("1");
-    expect(typeValueToString(T.literal("hi"))).toBe('"hi"');
-    expect(typeValueToString(T.literal(true))).toBe("true");
-    expect(typeValueToString(T.literal(null))).toBe("null");
-    expect(typeValueToString(T.literal(undefined))).toBe("undefined");
-  });
-
-  it("formats primitives", () => {
-    expect(typeValueToString(T.number)).toBe("number");
-    expect(typeValueToString(T.string)).toBe("string");
-  });
-
-  it("formats unions", () => {
-    const u = T.union(T.number, T.string);
-    expect(typeValueToString(u)).toBe("number | string");
-  });
-
-  it("formats objects", () => {
-    const obj = T.object({ x: T.number });
-    expect(typeValueToString(obj)).toBe("{ x: number }");
-  });
-
-  it("formats never and unknown", () => {
-    expect(typeValueToString(T.never)).toBe("never");
-    expect(typeValueToString(T.unknown)).toBe("unknown");
-  });
-});
-
-describe("narrowType", () => {
-  it("narrows union by predicate", () => {
-    const u = T.union(T.literal(1), T.literal("a"), T.literal(true));
-    const result = narrowType(u, (m) => m.kind === "literal" && typeof m.value === "number");
-    expect(typeValueEquals(result, T.literal(1))).toBe(true);
-  });
-
-  it("returns never if nothing matches", () => {
-    const result = narrowType(T.number, (m) => m.kind === "literal");
-    expect(result).toEqual(T.never);
-  });
-});
-
-describe("getPrimitiveTypeOf", () => {
-  it("returns typeof for literals", () => {
-    expect(getPrimitiveTypeOf(T.literal(1))).toBe("number");
-    expect(getPrimitiveTypeOf(T.literal("hi"))).toBe("string");
-    expect(getPrimitiveTypeOf(T.literal(null))).toBe("object");
-  });
-
-  it("returns type for primitives", () => {
-    expect(getPrimitiveTypeOf(T.number)).toBe("number");
-  });
-
-  it("returns object for object/array/tuple", () => {
-    expect(getPrimitiveTypeOf(T.object({}))).toBe("object");
-    expect(getPrimitiveTypeOf(T.array(T.number))).toBe("object");
-  });
-});
-
-describe("union absorption law (3 | number → number)", () => {
-  it("absorbs number literal into number", () => {
-    expect(T.union(T.literal(3), T.number)).toBe(T.number);
-    expect(T.union(T.number, T.literal(3))).toBe(T.number);
-  });
-
-  it("absorbs string literal into string", () => {
-    expect(T.union(T.literal("a"), T.string)).toBe(T.string);
-    expect(T.union(T.string, T.literal("a"))).toBe(T.string);
-  });
-
-  it("absorbs boolean literal into boolean", () => {
-    expect(T.union(T.literal(true), T.boolean)).toBe(T.boolean);
-    expect(T.union(T.boolean, T.literal(false))).toBe(T.boolean);
-  });
-
-  it("absorbs bigint literal into bigint", () => {
-    // LiteralValue 类型暂不含 bigint，运行时以 cast 构造
-    expect(T.union(T.literal(10n as unknown as LiteralValue), T.bigint)).toBe(T.bigint);
-  });
-
-  it("absorbs template literal into string", () => {
-    const tmpl = createTemplate([T.literal("x"), T.string]);
-    expect(T.union(tmpl, T.string)).toBe(T.string);
-  });
-
-  it("absorbs only matching base across mixed members (order-stable)", () => {
-    // 1 被 number 吸收，"a" 无 string 在场而保留
-    const u = T.union(T.literal(1), T.number, T.literal("a"));
-    expect(u.kind).toBe("union");
-    if (u.kind === "union") {
-      expect(u.members).toHaveLength(2);
-      expect(typeValueEquals(u.members[0], T.number)).toBe(true);
-      expect(typeValueEquals(u.members[1], T.literal("a"))).toBe(true);
-    }
-  });
-
-  it("keeps different-base literal union (1 | \"a\")", () => {
-    const u = T.union(T.literal(1), T.literal("a"));
-    expect(u.kind).toBe("union");
-    if (u.kind === "union") {
-      expect(u.members).toHaveLength(2);
-    }
-  });
-
-  it("keeps pure literal unions (\"a\" | \"b\", 2 | -9)", () => {
-    expect(typeValueToString(T.union(T.literal("a"), T.literal("b")))).toBe('"a" | "b"');
-    expect(typeValueToString(T.union(T.literal(2), T.literal(-9)))).toBe("2 | -9");
-  });
-
-  it("keeps undefined/null literal unions untouched", () => {
-    expect(typeValueToString(T.union(T.undefined, T.string))).toBe("undefined | string");
-    expect(typeValueToString(T.union(T.null, T.literal(1)))).toBe("null | 1");
-  });
-
-  it("keeps pure primitive unions untouched (number | string | boolean)", () => {
-    expect(typeValueToString(T.union(T.number, T.string, T.boolean))).toBe(
-      "number | string | boolean",
-    );
-  });
-});