@nudojs/core 0.2.0 → 0.3.1

package/src/ops.ts

@@ -1,210 +0,0 @@
-import { type TypeValue, T, isSubtypeOf, getRefinedBase } from "./type-value.ts";
-import { concatTemplates, isTemplate } from "./refinements/template.ts";
-
-function bothLiteral(
-  l: TypeValue,
-  r: TypeValue,
-): { lv: string | number | boolean | null | undefined; rv: string | number | boolean | null | undefined } | null {
-  if (l.kind === "literal" && r.kind === "literal") {
-    return { lv: l.value, rv: r.value };
-  }
-  return null;
-}
-
-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);
-  },
-
-  sub(left: TypeValue, right: TypeValue): TypeValue {
-    const lit = bothLiteral(left, right);
-    if (lit && typeof lit.lv === "number" && typeof lit.rv === "number") {
-      return T.literal(lit.lv - lit.rv);
-    }
-    return T.number;
-  },
-
-  mul(left: TypeValue, right: TypeValue): TypeValue {
-    const lit = bothLiteral(left, right);
-    if (lit && typeof lit.lv === "number" && typeof lit.rv === "number") {
-      return T.literal(lit.lv * lit.rv);
-    }
-    return T.number;
-  },
-
-  div(left: TypeValue, right: TypeValue): TypeValue {
-    const lit = bothLiteral(left, right);
-    if (lit && typeof lit.lv === "number" && typeof lit.rv === "number") {
-      return T.literal(lit.lv / lit.rv);
-    }
-    return T.number;
-  },
-
-  mod(left: TypeValue, right: TypeValue): TypeValue {
-    const lit = bothLiteral(left, right);
-    if (lit && typeof lit.lv === "number" && typeof lit.rv === "number") {
-      return T.literal(lit.lv % lit.rv);
-    }
-    return T.number;
-  },
-
-  strictEq(left: TypeValue, right: TypeValue): TypeValue {
-    const lit = bothLiteral(left, right);
-    if (lit) return T.literal(lit.lv === lit.rv);
-    return T.boolean;
-  },
-
-  strictNeq(left: TypeValue, right: TypeValue): TypeValue {
-    const lit = bothLiteral(left, right);
-    if (lit) return T.literal(lit.lv !== lit.rv);
-    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;
-  },
-
-  typeof_(operand: TypeValue): TypeValue {
-    if (operand.kind === "literal") {
-      const v = operand.value;
-      if (v === null) return T.literal("object");
-      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");
-    if (operand.kind === "function") return T.literal("function");
-    if (operand.kind === "promise") return T.literal("object");
-    if (operand.kind === "instance") return T.literal("object");
-    return T.string;
-  },
-
-  not(operand: TypeValue): TypeValue {
-    if (operand.kind === "literal") return T.literal(!operand.value);
-    return T.boolean;
-  },
-
-  neg(operand: TypeValue): TypeValue {
-    if (operand.kind === "literal" && typeof operand.value === "number") {
-      return T.literal(-operand.value);
-    }
-    return T.number;
-  },
-} as const;
-
-const binaryOpMap: Record<string, (l: TypeValue, r: TypeValue) => TypeValue> = {
-  "+": Ops.add,
-  "-": Ops.sub,
-  "*": Ops.mul,
-  "/": Ops.div,
-  "%": Ops.mod,
-  "===": 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/index.ts

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

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.ts

@@ -1,178 +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 function isTemplate(tv: TypeValue): boolean {
-  return tv.kind === "refined" && Array.isArray(tv.refinement.meta.parts);
-}
-
-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]);
-}