@nudojs/core 0.1.0 → 0.2.0

package/src/__tests__/ops-refined.test.ts

@@ -0,0 +1,194 @@
+import { describe, it, expect } from "vitest";
+import { T, typeValueEquals } from "../type-value.ts";
+import { dispatchBinaryOp, dispatchMethod, dispatchProperty } from "../ops.ts";
+import { createTemplate, isTemplate } from "../refinements/template.ts";
+import { createRange } from "../refinements/range.ts";
+
+describe("dispatchBinaryOp", () => {
+  describe("refined fallback", () => {
+    it("falls back to base type when no ops defined", () => {
+      const odd = T.refine(T.number, { name: "odd", meta: {} });
+      const result = dispatchBinaryOp("+", odd, T.literal(1));
+      expect(result.kind).toBe("primitive");
+    });
+
+    it("uses custom ops when defined", () => {
+      const odd = T.refine(T.number, {
+        name: "odd",
+        meta: {},
+        ops: {
+          "%"(self, other) {
+            if (other.kind === "literal" && other.value === 2) return T.literal(1);
+            return undefined;
+          },
+        },
+      });
+      const result = dispatchBinaryOp("%", odd, T.literal(2));
+      expect(typeValueEquals(result, T.literal(1))).toBe(true);
+    });
+
+    it("falls back when custom op returns undefined", () => {
+      const odd = T.refine(T.number, {
+        name: "odd",
+        meta: {},
+        ops: {
+          "%"(self, other) {
+            if (other.kind === "literal" && other.value === 2) return T.literal(1);
+            return undefined;
+          },
+        },
+      });
+      const result = dispatchBinaryOp("%", odd, T.literal(3));
+      expect(result.kind).toBe("primitive");
+    });
+  });
+
+  describe("template string via add", () => {
+    it("literal string + T.string produces template", () => {
+      const result = dispatchBinaryOp("+", T.literal("xy"), T.string);
+      expect(isTemplate(result)).toBe(true);
+    });
+
+    it("T.string + literal string produces template", () => {
+      const result = dispatchBinaryOp("+", T.string, T.literal("!"));
+      expect(isTemplate(result)).toBe(true);
+    });
+
+    it("template + template concatenates", () => {
+      const left = createTemplate([T.literal("a"), T.string]);
+      const right = createTemplate([T.literal("b"), T.string]);
+      const result = dispatchBinaryOp("+", left, right);
+      expect(isTemplate(result)).toBe(true);
+    });
+
+    it("two literal strings still produce literal", () => {
+      const result = dispatchBinaryOp("+", T.literal("a"), T.literal("b"));
+      expect(typeValueEquals(result, T.literal("ab"))).toBe(true);
+    });
+
+    it("T.string + T.string stays T.string", () => {
+      const result = dispatchBinaryOp("+", T.string, T.string);
+      expect(typeValueEquals(result, T.string)).toBe(true);
+    });
+  });
+
+  describe("range comparison ops", () => {
+    it("range(min:0) >= 0 is true", () => {
+      const r = createRange({ min: 0 });
+      const result = dispatchBinaryOp(">=", r, T.literal(0));
+      expect(typeValueEquals(result, T.literal(true))).toBe(true);
+    });
+
+    it("range(min:0) >= -1 is true", () => {
+      const r = createRange({ min: 0 });
+      const result = dispatchBinaryOp(">=", r, T.literal(-1));
+      expect(typeValueEquals(result, T.literal(true))).toBe(true);
+    });
+
+    it("range(max:100) > 200 is false", () => {
+      const r = createRange({ max: 100 });
+      const result = dispatchBinaryOp(">", r, T.literal(200));
+      expect(typeValueEquals(result, T.literal(false))).toBe(true);
+    });
+
+    it("range(min:0, max:100) > 50 is uncertain (boolean)", () => {
+      const r = createRange({ min: 0, max: 100 });
+      const result = dispatchBinaryOp(">", r, T.literal(50));
+      expect(typeValueEquals(result, T.boolean)).toBe(true);
+    });
+
+    it("range(max:10) <= 10 is true", () => {
+      const r = createRange({ max: 10 });
+      const result = dispatchBinaryOp("<=", r, T.literal(10));
+      expect(typeValueEquals(result, T.literal(true))).toBe(true);
+    });
+
+    it("range(min:5) < 3 is false", () => {
+      const r = createRange({ min: 5 });
+      const result = dispatchBinaryOp("<", r, T.literal(3));
+      expect(typeValueEquals(result, T.literal(false))).toBe(true);
+    });
+  });
+});
+
+describe("dispatchMethod", () => {
+  describe("template startsWith", () => {
+    it("known prefix matches", () => {
+      const tmpl = createTemplate([T.literal("xy"), T.string]);
+      const result = dispatchMethod(tmpl, "startsWith", [T.literal("x")]);
+      expect(result).toBeDefined();
+      expect(typeValueEquals(result!, T.literal(true))).toBe(true);
+    });
+
+    it("known prefix full match", () => {
+      const tmpl = createTemplate([T.literal("xy"), T.string]);
+      const result = dispatchMethod(tmpl, "startsWith", [T.literal("xy")]);
+      expect(typeValueEquals(result!, T.literal(true))).toBe(true);
+    });
+
+    it("known prefix mismatch", () => {
+      const tmpl = createTemplate([T.literal("xy"), T.string]);
+      const result = dispatchMethod(tmpl, "startsWith", [T.literal("a")]);
+      expect(typeValueEquals(result!, T.literal(false))).toBe(true);
+    });
+
+    it("uncertain when search extends beyond prefix", () => {
+      const tmpl = createTemplate([T.literal("xy"), T.string]);
+      const result = dispatchMethod(tmpl, "startsWith", [T.literal("xyz")]);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe("template endsWith", () => {
+    it("known suffix matches", () => {
+      const tmpl = createTemplate([T.string, T.literal("!")]);
+      const result = dispatchMethod(tmpl, "endsWith", [T.literal("!")]);
+      expect(typeValueEquals(result!, T.literal(true))).toBe(true);
+    });
+
+    it("known suffix mismatch", () => {
+      const tmpl = createTemplate([T.string, T.literal("!")]);
+      const result = dispatchMethod(tmpl, "endsWith", [T.literal("?")]);
+      expect(typeValueEquals(result!, T.literal(false))).toBe(true);
+    });
+  });
+
+  describe("template includes", () => {
+    it("known fixed text includes substring", () => {
+      const tmpl = createTemplate([T.literal("hello"), T.string, T.literal("world")]);
+      const result = dispatchMethod(tmpl, "includes", [T.literal("hello")]);
+      expect(typeValueEquals(result!, T.literal(true))).toBe(true);
+    });
+
+    it("uncertain when not in fixed text", () => {
+      const tmpl = createTemplate([T.literal("hello"), T.string]);
+      const result = dispatchMethod(tmpl, "includes", [T.literal("xyz")]);
+      expect(result).toBeUndefined();
+    });
+  });
+
+  it("returns undefined for unknown methods", () => {
+    const tmpl = createTemplate([T.literal("x"), T.string]);
+    const result = dispatchMethod(tmpl, "unknownMethod", []);
+    expect(result).toBeUndefined();
+  });
+
+  it("returns undefined for non-refined types", () => {
+    const result = dispatchMethod(T.string, "startsWith", [T.literal("x")]);
+    expect(result).toBeUndefined();
+  });
+});
+
+describe("dispatchProperty", () => {
+  it("template length returns range", () => {
+    const tmpl = createTemplate([T.literal("xy"), T.string]);
+    const result = dispatchProperty(tmpl, "length");
+    expect(result).toBeDefined();
+    expect(result!.kind).toBe("refined");
+  });
+
+  it("returns undefined for non-refined types", () => {
+    const result = dispatchProperty(T.string, "length");
+    expect(result).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,210 @@
+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/index.ts

@@ -1,6 +1,7 @@
 export {
   type TypeValue,
   type LiteralValue,
+  type Refinement,
   T,
   typeValueEquals,
   simplifyUnion,
@@ -10,13 +11,30 @@ export {
   narrowType,
   subtractType,
   getPrimitiveTypeOf,
+  getRefinedBase,
   deepCloneTypeValue,
   mergeObjectProperties,
 } from "./type-value.ts";
 
-export { Ops, applyBinaryOp } from "./ops.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";

package/src/ops.ts

@@ -1,4 +1,5 @@
-import { type TypeValue, T, isSubtypeOf } from "./type-value.ts";
+import { type TypeValue, T, isSubtypeOf, getRefinedBase } from "./type-value.ts";
+import { concatTemplates, isTemplate } from "./refinements/template.ts";
 
 function bothLiteral(
   l: TypeValue,
@@ -16,7 +17,17 @@ export const Ops = {
     if (lit) {
       return T.literal((lit.lv as any) + (lit.rv as any));
     }
-    if (isSubtypeOf(left, T.string) || isSubtypeOf(right, T.string)) {
+
+    const leftIsString = isSubtypeOf(left, T.string) || isTemplate(left);
+    const rightIsString = isSubtypeOf(right, T.string) || isTemplate(right);
+    if (leftIsString || rightIsString) {
+      const hasStructure =
+        (left.kind === "literal" && typeof left.value === "string") ||
+        (right.kind === "literal" && typeof right.value === "string") ||
+        isTemplate(left) || isTemplate(right);
+      if (hasStructure) {
+        return concatTemplates(left, right);
+      }
       return T.string;
     }
     if (isSubtypeOf(left, T.number) && isSubtypeOf(right, T.number)) {
@@ -100,6 +111,7 @@ export const Ops = {
       return T.literal(typeof v);
     }
     if (operand.kind === "primitive") return T.literal(operand.type);
+    if (operand.kind === "refined") return Ops.typeof_(getRefinedBase(operand));
     if (operand.kind === "object") return T.literal("object");
     if (operand.kind === "array" || operand.kind === "tuple")
       return T.literal("object");
@@ -145,3 +157,54 @@ export function applyBinaryOp(
   if (!fn) return T.unknown;
   return fn(left, right);
 }
+
+export function dispatchBinaryOp(
+  op: string,
+  left: TypeValue,
+  right: TypeValue,
+): TypeValue {
+  if (left.kind === "refined" && left.refinement.ops?.[op]) {
+    const result = left.refinement.ops[op](left, right);
+    if (result !== undefined) return result;
+  }
+  if (right.kind === "refined" && right.refinement.ops?.[op]) {
+    const result = right.refinement.ops[op](right, left);
+    if (result !== undefined) return result;
+  }
+
+  const baseLeft = left.kind === "refined" ? left.base : left;
+  const baseRight = right.kind === "refined" ? right.base : right;
+  if (baseLeft !== left || baseRight !== right) {
+    return dispatchBinaryOp(op, baseLeft, baseRight);
+  }
+  return applyBinaryOp(op, left, right);
+}
+
+export function dispatchMethod(
+  receiver: TypeValue,
+  name: string,
+  args: TypeValue[],
+): TypeValue | undefined {
+  if (receiver.kind === "refined" && receiver.refinement.methods?.[name]) {
+    const result = receiver.refinement.methods[name](receiver, args);
+    if (result !== undefined) return result;
+  }
+  if (receiver.kind === "refined") {
+    return dispatchMethod(receiver.base, name, args);
+  }
+  return undefined;
+}
+
+export function dispatchProperty(
+  receiver: TypeValue,
+  name: string,
+): TypeValue | undefined {
+  if (receiver.kind === "refined" && receiver.refinement.properties?.[name]) {
+    const result = receiver.refinement.properties[name](receiver);
+    if (result !== undefined) return result;
+  }
+  if (receiver.kind === "refined") {
+    return dispatchProperty(receiver.base, name);
+  }
+  return undefined;
+}

package/src/refinements/index.ts

@@ -0,0 +1,2 @@
+export { createTemplate, isTemplate, getTemplateParts, concatTemplates, getKnownPrefix, getKnownSuffix } from "./template.ts";
+export { createRange, isRange, getRangeMeta, type RangeMeta } from "./range.ts";

package/src/refinements/range.ts

@@ -0,0 +1,86 @@
+import { type TypeValue, type Refinement, T } from "../type-value.ts";
+
+export type RangeMeta = {
+  min?: number;
+  max?: number;
+  integer?: boolean;
+};
+
+function formatRangeName(meta: RangeMeta): string {
+  const parts: string[] = [];
+  if (meta.integer) parts.push("integer");
+  else parts.push("number");
+
+  const constraints: string[] = [];
+  if (meta.min != null) constraints.push(`>= ${meta.min}`);
+  if (meta.max != null) constraints.push(`<= ${meta.max}`);
+  if (constraints.length > 0) parts.push(`(${constraints.join(", ")})`);
+
+  return parts.join(" ");
+}
+
+function createRangeRefinement(meta: RangeMeta): Refinement {
+  return {
+    name: formatRangeName(meta),
+    meta: { ...meta },
+    check(value: unknown) {
+      if (typeof value !== "number") return false;
+      if (meta.integer && !Number.isInteger(value)) return false;
+      if (meta.min != null && value < meta.min) return false;
+      if (meta.max != null && value > meta.max) return false;
+      return true;
+    },
+    ops: {
+      ">="(self: TypeValue, other: TypeValue) {
+        const m = getRangeMeta(self);
+        if (!m || other.kind !== "literal" || typeof other.value !== "number") return undefined;
+        if (m.min != null && m.min >= other.value) return T.literal(true);
+        if (m.max != null && m.max < other.value) return T.literal(false);
+        return undefined;
+      },
+      ">"(self: TypeValue, other: TypeValue) {
+        const m = getRangeMeta(self);
+        if (!m || other.kind !== "literal" || typeof other.value !== "number") return undefined;
+        if (m.min != null && m.min > other.value) return T.literal(true);
+        if (m.max != null && m.max <= other.value) return T.literal(false);
+        return undefined;
+      },
+      "<="(self: TypeValue, other: TypeValue) {
+        const m = getRangeMeta(self);
+        if (!m || other.kind !== "literal" || typeof other.value !== "number") return undefined;
+        if (m.max != null && m.max <= other.value) return T.literal(true);
+        if (m.min != null && m.min > other.value) return T.literal(false);
+        return undefined;
+      },
+      "<"(self: TypeValue, other: TypeValue) {
+        const m = getRangeMeta(self);
+        if (!m || other.kind !== "literal" || typeof other.value !== "number") return undefined;
+        if (m.max != null && m.max < other.value) return T.literal(true);
+        if (m.min != null && m.min >= other.value) return T.literal(false);
+        return undefined;
+      },
+    },
+  };
+}
+
+export function createRange(meta: RangeMeta): TypeValue {
+  if (meta.min != null && meta.max != null && meta.min === meta.max) {
+    return T.literal(meta.min);
+  }
+  return T.refine(T.number, createRangeRefinement(meta));
+}
+
+export function isRange(tv: TypeValue): boolean {
+  if (tv.kind !== "refined") return false;
+  const m = tv.refinement.meta;
+  return m.min !== undefined || m.max !== undefined || m.integer !== undefined;
+}
+
+export function getRangeMeta(tv: TypeValue): RangeMeta | undefined {
+  if (tv.kind !== "refined") return undefined;
+  const m = tv.refinement.meta;
+  if (m.min !== undefined || m.max !== undefined || m.integer !== undefined) {
+    return m as RangeMeta;
+  }
+  return undefined;
+}