@nudojs/core 0.3.0 → 0.4.0

package/src/mock-helpers.ts

@@ -1,166 +0,0 @@
-/**
- * Nudo Mock 帮助函数
- *
- * 提供类型安全的 mock 创建，替代 sinon 表达式
- */
-
-import { type TypeValue, T, typeValueEquals } from "./type-value.ts";
-import type { Environment } from "./environment.ts";
-
-export type MockHelper = {
-  kind: "mock-helper";
-  returnValue?: TypeValue;
-  resolvedValue?: TypeValue;
-  rejectedValue?: TypeValue;
-  implementation?: (...args: TypeValue[]) => TypeValue;
-  onFirstCallValue?: TypeValue;
-  onSecondCallValue?: TypeValue;
-  withArgsCases?: { args: TypeValue[]; returnValue: TypeValue }[];
-  callsFakeImpl?: TypeValue;
-};
-
-/**
- * 创建一个 stub mock
- * 用法: @nudo:mock fetch = stub()
- */
-export function stub(): MockHelper {
-  return { kind: "mock-helper" };
-}
-
-/**
- * 创建一个返回指定值的 stub
- * 用法: @nudo:mock fetch = stub().returns({ data: "test" })
- */
-stub.returns = function(value: TypeValue): MockHelper {
-  return { kind: "mock-helper", returnValue: value };
-};
-
-/**
- * 创建一个返回 Promise 的 stub
- * 用法: @nudo:mock fetch = stub().resolves({ data: "test" })
- */
-stub.resolves = function(value: TypeValue): MockHelper {
-  return { kind: "mock-helper", resolvedValue: value };
-};
-
-/**
- * 创建一个拒绝 Promise 的 stub
- * 用法: @nudo:mock fetch = stub().rejects(new Error("fail"))
- */
-stub.rejects = function(value: TypeValue): MockHelper {
-  return { kind: "mock-helper", rejectedValue: value };
-};
-
-stub.onFirstCall = function(value: TypeValue): MockHelper {
-  return { kind: "mock-helper", onFirstCallValue: value };
-};
-
-stub.onSecondCall = function(value: TypeValue): MockHelper {
-  return { kind: "mock-helper", onSecondCallValue: value };
-};
-
-stub.withArgs = function(...args: TypeValue[]): MockHelper {
-  return { kind: "mock-helper", withArgsCases: [{ args, returnValue: T.unknown }] };
-};
-
-stub.callsFake = function(fn: TypeValue): MockHelper {
-  return { kind: "mock-helper", callsFakeImpl: fn };
-};
-
-/**
- * 创建一个 spy mock
- * 用法: @nudo:mock handler = spy()
- */
-export function spy(): MockHelper {
-  return { kind: "mock-helper" };
-}
-
-spy.returns = function(value: TypeValue): MockHelper {
-  return { kind: "mock-helper", returnValue: value };
-};
-
-/**
- * 创建一个 mock
- * 用法: @nudo:mock service = mock()
- */
-export function mock(): MockHelper {
-  return { kind: "mock-helper" };
-}
-
-/**
- * withArgs 实参匹配（sinon 深比较的保守近似）：
- * - 字面量声明要求实参为同值字面量（withArgs(21) 只匹配调用实参 literal 21）；
- * - primitive 声明（T.number 等）接受同源字面量（21 是 number）；
- * - 其余（unknown 声明等）不视为可证明匹配，走默认 stub 行为。
- */
-function mockArgMatches(declared: TypeValue, actual: TypeValue | undefined): boolean {
-  if (actual === undefined) return false;
-  if (typeValueEquals(declared, actual)) return true;
-  if (declared.kind === "primitive" && actual.kind === "literal") {
-    const t = typeof actual.value;
-    return (
-      (declared.type === "number" && t === "number") ||
-      (declared.type === "string" && t === "string") ||
-      (declared.type === "boolean" && t === "boolean") ||
-      (declared.type === "bigint" && t === "bigint") ||
-      (declared.type === "symbol" && t === "symbol")
-    );
-  }
-  return false;
-}
-
-/**
- * 将 MockHelper 转换为 TypeValue
- */
-export function mockHelperToTypeValue(helper: MockHelper, env: Environment): TypeValue {
-  // callsFake(fn)（sinon 语义）：stub 的调用 = 以实参执行 fn。
-  // 直接绑定 fn 本身，与 @nudo:mock f = (x) => ... 的箭头函数值绑定走同一机制
-  // （evaluator callFunction 的参数绑定 + 函数体求值）。不能设 _directReturn ——
-  // 那会把「fake 函数值」本身当调用结果传播，经 HOF 进一步污染下游。
-  if (helper.callsFakeImpl) {
-    if (helper.callsFakeImpl.kind === "function") {
-      return helper.callsFakeImpl;
-    }
-    // 非函数 fake 无「以实参执行」语义可言，退化为直接返回该值
-    const plain = T.fn(["...args"], { type: "BlockStatement", body: [] } as any, env);
-    (plain as any)._directReturn = helper.callsFakeImpl;
-    return plain;
-  }
-
-  let defaultReturn: TypeValue;
-  if (helper.resolvedValue) {
-    defaultReturn = T.promise(helper.resolvedValue);
-  } else if (helper.rejectedValue) {
-    defaultReturn = T.never;
-  } else if (helper.returnValue) {
-    defaultReturn = helper.returnValue;
-  } else if (helper.onFirstCallValue) {
-    defaultReturn = helper.onFirstCallValue;
-  } else {
-    defaultReturn = T.unknown;
-  }
-
-  // withArgs 分派（sinon 语义）：实参匹配的链返回其 returnValue，未命中走默认
-  // stub 行为。经 fnSig impl 在调用时拿实参判定，优先于任何固定返回值。
-  if (helper.withArgsCases?.length) {
-    const cases = helper.withArgsCases;
-    return T.fnSig(
-      cases[0].args.map(() => T.unknown),
-      T.union(...cases.map((c) => c.returnValue), defaultReturn),
-      T.never,
-      (args) => {
-        for (const c of cases) {
-          if (c.args.every((a, i) => mockArgMatches(a, args[i]))) {
-            return c.returnValue;
-          }
-        }
-        return defaultReturn;
-      },
-    );
-  }
-
-  const body = { type: "BlockStatement", body: [] } as any;
-  const fn = T.fn(["...args"], body, env);
-  (fn as any)._directReturn = defaultReturn;
-  return fn;
-}

package/src/ops.ts

@@ -1,191 +0,0 @@
-/**
- * 残差 IR 兜底（不是类型运算真理源）。
- *
- * 真理在 algebra：算术/比较/相等/typeof/!/−/字符串词法序/nullish 均走 Abs。
- * 这里只保留：
- * - add：代数拒绝时的混合 `+`
- * - 比较/相等：代数无法判定时的保守 boolean / 字面量折叠
- * - dispatchMethod/Property：宿主 refined 扩展（startsWith、length…）
- */
-import { type TypeValue, type LiteralValue, T, isSubtypeOf } from "./type-value.ts";
-import { concatTemplates, isTemplate } from "./refinements/template.ts";
-
-function bothLiteral(
-  l: TypeValue,
-  r: TypeValue,
-): { lv: LiteralValue; rv: LiteralValue } | null {
-  if (l.kind === "literal" && r.kind === "literal") {
-    return { lv: l.value, rv: r.value };
-  }
-  return null;
-}
-
-function isNullishLiteral(tv: TypeValue): boolean {
-  return tv.kind === "literal" && (tv.value === null || tv.value === undefined);
-}
-
-function definitelyNotNullish(tv: TypeValue): boolean {
-  switch (tv.kind) {
-    case "literal":
-      return tv.value !== null && tv.value !== undefined;
-    case "primitive":
-    case "object":
-    case "array":
-    case "tuple":
-    case "function":
-    case "instance":
-    case "promise":
-      return true;
-    case "refined":
-      return definitelyNotNullish(tv.base);
-    case "union":
-      return tv.members.every(definitelyNotNullish);
-    default:
-      return false;
-  }
-}
-
-export const Ops = {
-  add(left: TypeValue, right: TypeValue): TypeValue {
-    const lit = bothLiteral(left, right);
-    if (lit) {
-      return T.literal((lit.lv as any) + (lit.rv as any));
-    }
-    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)) {
-      return T.number;
-    }
-    return T.union(T.number, T.string);
-  },
-
-  strictEq(left: TypeValue, right: TypeValue): TypeValue {
-    const lit = bothLiteral(left, right);
-    if (lit) return T.literal(lit.lv === lit.rv);
-    if ((isNullishLiteral(right) && definitelyNotNullish(left)) ||
-        (isNullishLiteral(left) && definitelyNotNullish(right))) {
-      return T.literal(false);
-    }
-    return T.boolean;
-  },
-
-  strictNeq(left: TypeValue, right: TypeValue): TypeValue {
-    const lit = bothLiteral(left, right);
-    if (lit) return T.literal(lit.lv !== lit.rv);
-    if ((isNullishLiteral(right) && definitelyNotNullish(left)) ||
-        (isNullishLiteral(left) && definitelyNotNullish(right))) {
-      return T.literal(true);
-    }
-    return T.boolean;
-  },
-
-  gt(left: TypeValue, right: TypeValue): TypeValue {
-    const lit = bothLiteral(left, right);
-    if (lit) return T.literal((lit.lv as any) > (lit.rv as any));
-    return T.boolean;
-  },
-
-  lt(left: TypeValue, right: TypeValue): TypeValue {
-    const lit = bothLiteral(left, right);
-    if (lit) return T.literal((lit.lv as any) < (lit.rv as any));
-    return T.boolean;
-  },
-
-  gte(left: TypeValue, right: TypeValue): TypeValue {
-    const lit = bothLiteral(left, right);
-    if (lit) return T.literal((lit.lv as any) >= (lit.rv as any));
-    return T.boolean;
-  },
-
-  lte(left: TypeValue, right: TypeValue): TypeValue {
-    const lit = bothLiteral(left, right);
-    if (lit) return T.literal((lit.lv as any) <= (lit.rv as any));
-    return T.boolean;
-  },
-
-  not(operand: TypeValue): TypeValue {
-    if (operand.kind === "literal") return T.literal(!operand.value);
-    return T.boolean;
-  },
-} as const;
-
-const binaryOpMap: Record<string, (l: TypeValue, r: TypeValue) => TypeValue> = {
-  "+": Ops.add,
-  "===": Ops.strictEq,
-  "!==": Ops.strictNeq,
-  ">": Ops.gt,
-  "<": Ops.lt,
-  ">=": Ops.gte,
-  "<=": Ops.lte,
-};
-
-export function applyBinaryOp(
-  op: string,
-  left: TypeValue,
-  right: TypeValue,
-): TypeValue {
-  const fn = binaryOpMap[op];
-  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/range.ts

@@ -1,86 +0,0 @@
-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;
-}

package/src/refinements/template-predicates.ts

@@ -1,11 +0,0 @@
-import type { TypeValue } from "../type-value.ts";
-
-/**
- * 模板字面量谓词，独立于 template.ts 以断开运行时循环引用：
- * type-value.ts（联合吸收律）与 template.ts 都依赖本模块，而本模块对
- * type-value.ts 只有 `import type` 边（编译后消失），运行时依赖保持单向
- * type-value.ts / template.ts -> template-predicates.ts。
- */
-export function isTemplate(tv: TypeValue): boolean {
-  return tv.kind === "refined" && Array.isArray(tv.refinement.meta.parts);
-}

package/src/refinements/template.ts

@@ -1,176 +0,0 @@
-import { type TypeValue, type Refinement, T, typeValueToString } from "../type-value.ts";
-import { createRange } from "./range.ts";
-
-export function getKnownPrefix(parts: TypeValue[]): string {
-  let prefix = "";
-  for (const p of parts) {
-    if (p.kind === "literal" && typeof p.value === "string") {
-      prefix += p.value;
-    } else {
-      break;
-    }
-  }
-  return prefix;
-}
-
-export function getKnownSuffix(parts: TypeValue[]): string {
-  let suffix = "";
-  for (let i = parts.length - 1; i >= 0; i--) {
-    const p = parts[i];
-    if (p.kind === "literal" && typeof p.value === "string") {
-      suffix = p.value + suffix;
-    } else {
-      break;
-    }
-  }
-  return suffix;
-}
-
-function getFixedLength(parts: TypeValue[]): number {
-  let len = 0;
-  for (const p of parts) {
-    if (p.kind === "literal" && typeof p.value === "string") {
-      len += p.value.length;
-    }
-  }
-  return len;
-}
-
-function getAllFixedText(parts: TypeValue[]): string {
-  return parts
-    .filter((p): p is TypeValue & { kind: "literal" } => p.kind === "literal" && typeof p.value === "string")
-    .map((p) => p.value as string)
-    .join("");
-}
-
-function formatTemplateName(parts: TypeValue[]): string {
-  const inner = parts
-    .map((p) => (p.kind === "literal" && typeof p.value === "string" ? p.value : `\${${typeValueToString(p)}}`))
-    .join("");
-  return `\`${inner}\``;
-}
-
-function normalizeParts(parts: TypeValue[]): TypeValue[] {
-  const result: TypeValue[] = [];
-  for (const p of parts) {
-    const last = result[result.length - 1];
-    if (
-      last?.kind === "literal" && typeof last.value === "string" &&
-      p.kind === "literal" && typeof p.value === "string"
-    ) {
-      result[result.length - 1] = T.literal(last.value + p.value);
-    } else if (
-      last?.kind === "primitive" && last.type === "string" &&
-      p.kind === "primitive" && p.type === "string"
-    ) {
-      // T.string + T.string collapses to T.string
-    } else {
-      result.push(p);
-    }
-  }
-  return result;
-}
-
-function createTemplateRefinement(parts: TypeValue[]): Refinement {
-  return {
-    name: formatTemplateName(parts),
-    meta: { parts },
-    check(value: unknown) {
-      if (typeof value !== "string") return false;
-      return matchesTemplate(value, parts);
-    },
-    ops: {
-      "+"(self: TypeValue, other: TypeValue) {
-        return concatTemplates(self, other);
-      },
-    },
-    methods: {
-      startsWith(_self: TypeValue, args: TypeValue[]) {
-        const arg = args[0];
-        if (arg?.kind !== "literal" || typeof arg.value !== "string") return undefined;
-        const prefix = getKnownPrefix((_self as any).refinement.meta.parts as TypeValue[]);
-        const search = arg.value;
-        if (prefix.length >= search.length) {
-          return T.literal(prefix.startsWith(search));
-        }
-        if (search.startsWith(prefix)) return undefined;
-        return T.literal(false);
-      },
-      endsWith(_self: TypeValue, args: TypeValue[]) {
-        const arg = args[0];
-        if (arg?.kind !== "literal" || typeof arg.value !== "string") return undefined;
-        const suffix = getKnownSuffix((_self as any).refinement.meta.parts as TypeValue[]);
-        const search = arg.value;
-        if (suffix.length >= search.length) {
-          return T.literal(suffix.endsWith(search));
-        }
-        if (search.endsWith(suffix)) return undefined;
-        return T.literal(false);
-      },
-      includes(_self: TypeValue, args: TypeValue[]) {
-        const arg = args[0];
-        if (arg?.kind !== "literal" || typeof arg.value !== "string") return undefined;
-        const fixed = getAllFixedText((_self as any).refinement.meta.parts as TypeValue[]);
-        if (fixed.includes(arg.value)) return T.literal(true);
-        return undefined;
-      },
-    },
-    properties: {
-      length(_self: TypeValue) {
-        const parts = (_self as any).refinement.meta.parts as TypeValue[];
-        const hasAbstract = parts.some((p) => p.kind !== "literal");
-        if (!hasAbstract) return undefined;
-        const minLen = getFixedLength(parts);
-        return createRange({ min: minLen });
-      },
-    },
-  };
-}
-
-function matchesTemplate(value: string, parts: TypeValue[]): boolean {
-  let pos = 0;
-  for (let i = 0; i < parts.length; i++) {
-    const p = parts[i];
-    if (p.kind === "literal" && typeof p.value === "string") {
-      if (!value.startsWith(p.value, pos)) return false;
-      pos += p.value.length;
-    } else {
-      if (i === parts.length - 1) return true;
-      const next = parts[i + 1];
-      if (next?.kind === "literal" && typeof next.value === "string") {
-        const idx = value.indexOf(next.value, pos);
-        if (idx === -1) return false;
-        pos = idx;
-      } else {
-        return true;
-      }
-    }
-  }
-  return pos === value.length;
-}
-
-export function createTemplate(parts: TypeValue[]): TypeValue {
-  const normalized = normalizeParts(parts);
-  if (normalized.length === 1 && normalized[0].kind === "literal") {
-    return normalized[0];
-  }
-  if (normalized.length === 1 && normalized[0].kind === "primitive" && normalized[0].type === "string") {
-    return T.string;
-  }
-  return T.refine(T.string, createTemplateRefinement(normalized));
-}
-
-export { isTemplate } from "./template-predicates.ts";
-
-export function getTemplateParts(tv: TypeValue): TypeValue[] | undefined {
-  if (tv.kind === "refined" && Array.isArray(tv.refinement.meta.parts)) {
-    return tv.refinement.meta.parts as TypeValue[];
-  }
-  return undefined;
-}
-
-export function concatTemplates(left: TypeValue, right: TypeValue): TypeValue {
-  const leftParts = getTemplateParts(left) ?? [left];
-  const rightParts = getTemplateParts(right) ?? [right];
-  return createTemplate([...leftParts, ...rightParts]);
-}