@nudojs/core 0.2.0 → 0.3.1

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,213 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,40 +0,0 @@
-export {
-  type TypeValue,
-  type LiteralValue,
-  type Refinement,
-  T,
-  typeValueEquals,
-  simplifyUnion,
-  widenLiteral,
-  isSubtypeOf,
-  typeValueToString,
-  narrowType,
-  subtractType,
-  getPrimitiveTypeOf,
-  getRefinedBase,
-  deepCloneTypeValue,
-  mergeObjectProperties,
-} from "./type-value.ts";
-
-export { Ops, applyBinaryOp, dispatchBinaryOp, dispatchMethod, dispatchProperty } from "./ops.ts";
-
-export {
-  type Environment,
-  createEnvironment,
-} from "./environment.ts";
-
-export {
-  createTemplate,
-  isTemplate,
-  getTemplateParts,
-  concatTemplates,
-  getKnownPrefix,
-  getKnownSuffix,
-} from "./refinements/template.ts";
-
-export {
-  createRange,
-  isRange,
-  getRangeMeta,
-  type RangeMeta,
-} from "./refinements/range.ts";