@nudojs/core 0.1.0

package/src/__tests__/ops.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect } from "vitest";
+import { Ops, applyBinaryOp } from "../ops.ts";
+import { T, typeValueEquals } from "../type-value.ts";
+
+describe("Ops.add", () => {
+  it("adds two literal numbers", () => {
+    expect(typeValueEquals(Ops.add(T.literal(1), T.literal(2)), T.literal(3))).toBe(true);
+  });
+
+  it("concatenates two literal strings", () => {
+    expect(typeValueEquals(Ops.add(T.literal("a"), T.literal("b")), T.literal("ab"))).toBe(true);
+  });
+
+  it("returns number for abstract numbers", () => {
+    expect(typeValueEquals(Ops.add(T.number, T.number), T.number)).toBe(true);
+  });
+
+  it("returns string when one side is string", () => {
+    expect(typeValueEquals(Ops.add(T.number, T.string), T.string)).toBe(true);
+    expect(typeValueEquals(Ops.add(T.string, T.literal(1)), T.string)).toBe(true);
+  });
+});
+
+describe("Ops.sub / mul / div / mod", () => {
+  it("computes literal arithmetic", () => {
+    expect(typeValueEquals(Ops.sub(T.literal(5), T.literal(3)), T.literal(2))).toBe(true);
+    expect(typeValueEquals(Ops.mul(T.literal(3), T.literal(4)), T.literal(12))).toBe(true);
+    expect(typeValueEquals(Ops.div(T.literal(10), T.literal(2)), T.literal(5))).toBe(true);
+    expect(typeValueEquals(Ops.mod(T.literal(7), T.literal(3)), T.literal(1))).toBe(true);
+  });
+
+  it("returns number for abstract operands", () => {
+    expect(typeValueEquals(Ops.sub(T.number, T.number), T.number)).toBe(true);
+    expect(typeValueEquals(Ops.mul(T.number, T.literal(2)), T.number)).toBe(true);
+  });
+});
+
+describe("Ops.strictEq / strictNeq", () => {
+  it("compares literals", () => {
+    expect(typeValueEquals(Ops.strictEq(T.literal(1), T.literal(1)), T.literal(true))).toBe(true);
+    expect(typeValueEquals(Ops.strictEq(T.literal(1), T.literal(2)), T.literal(false))).toBe(true);
+    expect(typeValueEquals(Ops.strictNeq(T.literal(1), T.literal(2)), T.literal(true))).toBe(true);
+  });
+
+  it("returns boolean for abstract operands", () => {
+    expect(typeValueEquals(Ops.strictEq(T.number, T.number), T.boolean)).toBe(true);
+  });
+});
+
+describe("Ops.gt / lt / gte / lte", () => {
+  it("compares literal numbers", () => {
+    expect(typeValueEquals(Ops.gt(T.literal(3), T.literal(2)), T.literal(true))).toBe(true);
+    expect(typeValueEquals(Ops.lt(T.literal(1), T.literal(2)), T.literal(true))).toBe(true);
+    expect(typeValueEquals(Ops.gte(T.literal(2), T.literal(2)), T.literal(true))).toBe(true);
+    expect(typeValueEquals(Ops.lte(T.literal(3), T.literal(2)), T.literal(false))).toBe(true);
+  });
+
+  it("returns boolean for abstract operands", () => {
+    expect(typeValueEquals(Ops.gt(T.number, T.number), T.boolean)).toBe(true);
+  });
+});
+
+describe("Ops.typeof_", () => {
+  it("returns literal typeof for known types", () => {
+    expect(typeValueEquals(Ops.typeof_(T.literal(1)), T.literal("number"))).toBe(true);
+    expect(typeValueEquals(Ops.typeof_(T.literal("hi")), T.literal("string"))).toBe(true);
+    expect(typeValueEquals(Ops.typeof_(T.literal(null)), T.literal("object"))).toBe(true);
+    expect(typeValueEquals(Ops.typeof_(T.number), T.literal("number"))).toBe(true);
+    expect(typeValueEquals(Ops.typeof_(T.object({})), T.literal("object"))).toBe(true);
+  });
+});
+
+describe("Ops.not", () => {
+  it("negates literal booleans", () => {
+    expect(typeValueEquals(Ops.not(T.literal(true)), T.literal(false))).toBe(true);
+    expect(typeValueEquals(Ops.not(T.literal(false)), T.literal(true))).toBe(true);
+  });
+
+  it("negates truthy/falsy literals", () => {
+    expect(typeValueEquals(Ops.not(T.literal(0)), T.literal(true))).toBe(true);
+    expect(typeValueEquals(Ops.not(T.literal("")), T.literal(true))).toBe(true);
+    expect(typeValueEquals(Ops.not(T.literal(1)), T.literal(false))).toBe(true);
+  });
+
+  it("returns boolean for abstract types", () => {
+    expect(typeValueEquals(Ops.not(T.number), T.boolean)).toBe(true);
+  });
+});
+
+describe("Ops.neg", () => {
+  it("negates literal number", () => {
+    expect(typeValueEquals(Ops.neg(T.literal(5)), T.literal(-5))).toBe(true);
+  });
+
+  it("returns number for abstract", () => {
+    expect(typeValueEquals(Ops.neg(T.number), T.number)).toBe(true);
+  });
+});
+
+describe("applyBinaryOp", () => {
+  it("dispatches to correct op", () => {
+    expect(typeValueEquals(applyBinaryOp("+", T.literal(1), T.literal(2)), T.literal(3))).toBe(true);
+    expect(typeValueEquals(applyBinaryOp("===", T.literal(1), T.literal(1)), T.literal(true))).toBe(true);
+  });
+
+  it("returns unknown for unsupported op", () => {
+    expect(applyBinaryOp("**", T.number, T.number)).toEqual(T.unknown);
+  });
+});

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

@@ -0,0 +1,117 @@
+import { describe, it, expect } from "vitest";
+import {
+  T,
+  isSubtypeOf,
+  deepCloneTypeValue,
+  mergeObjectProperties,
+  typeValueEquals,
+} from "../type-value.ts";
+
+describe("isSubtypeOf: structural subtyping", () => {
+  it("object subtype: a has all properties of b with subtypes", () => {
+    const a = T.object({ x: T.literal(1), y: T.string, z: T.boolean });
+    const b = T.object({ x: T.number, y: T.string });
+    expect(isSubtypeOf(a, b)).toBe(true);
+  });
+
+  it("object not subtype: missing property", () => {
+    const a = T.object({ x: T.number });
+    const b = T.object({ x: T.number, y: T.string });
+    expect(isSubtypeOf(a, b)).toBe(false);
+  });
+
+  it("object not subtype: property type mismatch", () => {
+    const a = T.object({ x: T.string });
+    const b = T.object({ x: T.number });
+    expect(isSubtypeOf(a, b)).toBe(false);
+  });
+
+  it("array subtype: element is subtype", () => {
+    const a = T.array(T.literal(1));
+    const b = T.array(T.number);
+    expect(isSubtypeOf(a, b)).toBe(true);
+  });
+
+  it("array not subtype: element mismatch", () => {
+    const a = T.array(T.string);
+    const b = T.array(T.number);
+    expect(isSubtypeOf(a, b)).toBe(false);
+  });
+
+  it("tuple subtype: element-wise", () => {
+    const a = T.tuple([T.literal(1), T.literal("hi")]);
+    const b = T.tuple([T.number, T.string]);
+    expect(isSubtypeOf(a, b)).toBe(true);
+  });
+
+  it("tuple not subtype: length mismatch", () => {
+    const a = T.tuple([T.number]);
+    const b = T.tuple([T.number, T.string]);
+    expect(isSubtypeOf(a, b)).toBe(false);
+  });
+
+  it("tuple is subtype of array if all elements match", () => {
+    const a = T.tuple([T.literal(1), T.literal(2)]);
+    const b = T.array(T.number);
+    expect(isSubtypeOf(a, b)).toBe(true);
+  });
+
+  it("tuple not subtype of array if element mismatch", () => {
+    const a = T.tuple([T.literal(1), T.literal("hi")]);
+    const b = T.array(T.number);
+    expect(isSubtypeOf(a, b)).toBe(false);
+  });
+});
+
+describe("deepCloneTypeValue", () => {
+  it("clones object with new id", () => {
+    const obj = T.object({ x: T.number, y: T.string });
+    const cloned = deepCloneTypeValue(obj);
+    expect(cloned.kind).toBe("object");
+    if (cloned.kind === "object" && obj.kind === "object") {
+      expect(cloned.id).not.toBe(obj.id);
+      expect(cloned.properties.x).toEqual(obj.properties.x);
+      expect(cloned.properties.y).toEqual(obj.properties.y);
+    }
+  });
+
+  it("clones nested objects", () => {
+    const inner = T.object({ a: T.literal(1) });
+    const outer = T.object({ nested: inner });
+    const cloned = deepCloneTypeValue(outer);
+    if (cloned.kind === "object" && outer.kind === "object") {
+      const clonedInner = cloned.properties.nested;
+      expect(clonedInner.kind).toBe("object");
+      if (clonedInner.kind === "object" && inner.kind === "object") {
+        expect(clonedInner.id).not.toBe(inner.id);
+      }
+    }
+  });
+
+  it("returns primitives unchanged", () => {
+    expect(deepCloneTypeValue(T.number)).toBe(T.number);
+    expect(typeValueEquals(deepCloneTypeValue(T.literal(1)), T.literal(1))).toBe(true);
+  });
+});
+
+describe("mergeObjectProperties", () => {
+  it("merges two objects with overlapping keys", () => {
+    const a = T.object({ x: T.literal(1), y: T.literal("a") }) as any;
+    const b = T.object({ x: T.literal(2), z: T.boolean }) as any;
+    const merged = mergeObjectProperties(a, b);
+    if (merged.kind === "object") {
+      expect(Object.keys(merged.properties).sort()).toEqual(["x", "y", "z"]);
+      expect(merged.properties.y).toEqual(T.literal("a"));
+      expect(merged.properties.z).toEqual(T.boolean);
+    }
+  });
+
+  it("creates union for overlapping keys with different values", () => {
+    const a = T.object({ x: T.literal(1) }) as any;
+    const b = T.object({ x: T.literal(2) }) as any;
+    const merged = mergeObjectProperties(a, b);
+    if (merged.kind === "object") {
+      expect(merged.properties.x.kind).toBe("union");
+    }
+  });
+});

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

@@ -0,0 +1,94 @@
+import { describe, it, expect } from "vitest";
+import {
+  T,
+  typeValueToString,
+  typeValueEquals,
+  isSubtypeOf,
+  getPrimitiveTypeOf,
+  deepCloneTypeValue,
+} from "../type-value.ts";
+
+describe("PromiseType", () => {
+  it("creates a promise type", () => {
+    const p = T.promise(T.number);
+    expect(p.kind).toBe("promise");
+    if (p.kind === "promise") {
+      expect(p.value).toBe(T.number);
+    }
+  });
+
+  it("toString formats correctly", () => {
+    expect(typeValueToString(T.promise(T.number))).toBe("Promise<number>");
+    expect(typeValueToString(T.promise(T.string))).toBe("Promise<string>");
+    expect(typeValueToString(T.promise(T.union(T.number, T.string)))).toBe(
+      "Promise<number | string>",
+    );
+  });
+
+  it("equals works", () => {
+    expect(typeValueEquals(T.promise(T.number), T.promise(T.number))).toBe(true);
+    expect(typeValueEquals(T.promise(T.number), T.promise(T.string))).toBe(false);
+  });
+
+  it("isSubtypeOf works", () => {
+    expect(isSubtypeOf(T.promise(T.literal(1)), T.promise(T.number))).toBe(true);
+    expect(isSubtypeOf(T.promise(T.number), T.promise(T.string))).toBe(false);
+  });
+
+  it("getPrimitiveTypeOf returns object", () => {
+    expect(getPrimitiveTypeOf(T.promise(T.number))).toBe("object");
+  });
+
+  it("deepClone works", () => {
+    const p = T.promise(T.object({ x: T.number }));
+    const cloned = deepCloneTypeValue(p);
+    expect(typeValueEquals(cloned, p)).toBe(false);
+    expect(cloned.kind).toBe("promise");
+    if (cloned.kind === "promise" && cloned.value.kind === "object") {
+      expect(cloned.value.properties.x).toBe(T.number);
+    }
+  });
+});
+
+describe("InstanceType", () => {
+  it("creates an instance type", () => {
+    const inst = T.instanceOf("Error", { message: T.literal("oops") });
+    expect(inst.kind).toBe("instance");
+    if (inst.kind === "instance") {
+      expect(inst.className).toBe("Error");
+      expect(inst.properties.message).toEqual(T.literal("oops"));
+    }
+  });
+
+  it("toString formats correctly", () => {
+    expect(typeValueToString(T.instanceOf("Error"))).toBe("Error");
+    expect(typeValueToString(T.instanceOf("Error", { message: T.literal("oops") }))).toBe(
+      'Error { message: "oops" }',
+    );
+  });
+
+  it("equals checks className", () => {
+    expect(typeValueEquals(T.instanceOf("Error"), T.instanceOf("Error"))).toBe(true);
+    expect(typeValueEquals(T.instanceOf("Error"), T.instanceOf("TypeError"))).toBe(false);
+  });
+
+  it("isSubtypeOf handles error hierarchy", () => {
+    expect(isSubtypeOf(T.instanceOf("TypeError"), T.instanceOf("Error"))).toBe(true);
+    expect(isSubtypeOf(T.instanceOf("SyntaxError"), T.instanceOf("Error"))).toBe(true);
+    expect(isSubtypeOf(T.instanceOf("Error"), T.instanceOf("TypeError"))).toBe(false);
+  });
+
+  it("getPrimitiveTypeOf returns object", () => {
+    expect(getPrimitiveTypeOf(T.instanceOf("Error"))).toBe("object");
+  });
+
+  it("deepClone works", () => {
+    const inst = T.instanceOf("Error", { message: T.string });
+    const cloned = deepCloneTypeValue(inst);
+    expect(cloned.kind).toBe("instance");
+    if (cloned.kind === "instance") {
+      expect(cloned.className).toBe("Error");
+      expect(cloned.properties.message).toBe(T.string);
+    }
+  });
+});

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

@@ -0,0 +1,213 @@
+import { describe, it, expect } from "vitest";
+import {
+  T,
+  typeValueEquals,
+  simplifyUnion,
+  widenLiteral,
+  isSubtypeOf,
+  typeValueToString,
+  narrowType,
+  subtractType,
+  getPrimitiveTypeOf,
+} from "../type-value.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);
+  });
+});
+
+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");
+  });
+});

package/src/environment.ts

@@ -0,0 +1,69 @@
+import { type TypeValue, T } from "./type-value.ts";
+
+export type Environment = {
+  lookup(name: string): TypeValue;
+  bind(name: string, value: TypeValue): Environment;
+  update(name: string, value: TypeValue): boolean;
+  extend(bindings: Record<string, TypeValue>): Environment;
+  has(name: string): boolean;
+  snapshot(): Environment;
+  getOwnBindings(): Record<string, TypeValue>;
+};
+
+export function createEnvironment(
+  parent?: Environment,
+  bindings: Map<string, TypeValue> = new Map(),
+): Environment {
+  const store = new Map(bindings);
+
+  const env: Environment = {
+    lookup(name) {
+      const val = store.get(name);
+      if (val !== undefined) return val;
+      if (parent) return parent.lookup(name);
+      return T.undefined;
+    },
+
+    bind(name, value) {
+      store.set(name, value);
+      return env;
+    },
+
+    update(name, value) {
+      if (store.has(name)) {
+        store.set(name, value);
+        return true;
+      }
+      if (parent) return parent.update(name, value);
+      return false;
+    },
+
+    extend(newBindings) {
+      const childMap = new Map<string, TypeValue>();
+      for (const [k, v] of Object.entries(newBindings)) {
+        childMap.set(k, v);
+      }
+      return createEnvironment(env, childMap);
+    },
+
+    has(name) {
+      return store.has(name) || (parent?.has(name) ?? false);
+    },
+
+    snapshot() {
+      const clonedStore = new Map(store);
+      const clonedParent = parent?.snapshot();
+      return createEnvironment(clonedParent, clonedStore);
+    },
+
+    getOwnBindings() {
+      const result: Record<string, TypeValue> = {};
+      for (const [k, v] of store) {
+        result[k] = v;
+      }
+      return result;
+    },
+  };
+
+  return env;
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+export {
+  type TypeValue,
+  type LiteralValue,
+  T,
+  typeValueEquals,
+  simplifyUnion,
+  widenLiteral,
+  isSubtypeOf,
+  typeValueToString,
+  narrowType,
+  subtractType,
+  getPrimitiveTypeOf,
+  deepCloneTypeValue,
+  mergeObjectProperties,
+} from "./type-value.ts";
+
+export { Ops, applyBinaryOp } from "./ops.ts";
+
+export {
+  type Environment,
+  createEnvironment,
+} from "./environment.ts";