@nudojs/core 0.1.0

package/src/ops.ts

@@ -0,0 +1,147 @@
+import { type TypeValue, T, isSubtypeOf } from "./type-value.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));
+    }
+    if (isSubtypeOf(left, T.string) || isSubtypeOf(right, T.string)) {
+      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 === "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);
+}

package/src/type-value.ts

@@ -0,0 +1,332 @@
+import type { Node } from "@babel/types";
+import type { Environment } from "./environment.ts";
+
+// --- TypeValue discriminated union ---
+
+export type LiteralValue = string | number | boolean | null | undefined;
+
+export type TypeValue =
+  | { kind: "literal"; value: LiteralValue }
+  | {
+      kind: "primitive";
+      type: "number" | "string" | "boolean" | "bigint" | "symbol";
+    }
+  | { kind: "object"; properties: Record<string, TypeValue>; id: symbol }
+  | { kind: "array"; element: TypeValue }
+  | { kind: "tuple"; elements: TypeValue[] }
+  | {
+      kind: "function";
+      params: string[];
+      body: Node;
+      closure: Environment;
+    }
+  | { kind: "promise"; value: TypeValue }
+  | { kind: "instance"; className: string; properties: Record<string, TypeValue> }
+  | { kind: "union"; members: TypeValue[] }
+  | { kind: "never" }
+  | { kind: "unknown" };
+
+// --- T: static factory ---
+
+function createUnion(...members: TypeValue[]): TypeValue {
+  return simplifyUnion(members);
+}
+
+export const T = {
+  literal: (value: LiteralValue): TypeValue => ({ kind: "literal", value }),
+  number: { kind: "primitive", type: "number" } as TypeValue,
+  string: { kind: "primitive", type: "string" } as TypeValue,
+  boolean: { kind: "primitive", type: "boolean" } as TypeValue,
+  bigint: { kind: "primitive", type: "bigint" } as TypeValue,
+  symbol: { kind: "primitive", type: "symbol" } as TypeValue,
+  null: { kind: "literal", value: null } as TypeValue,
+  undefined: { kind: "literal", value: undefined } as TypeValue,
+  unknown: { kind: "unknown" } as TypeValue,
+  never: { kind: "never" } as TypeValue,
+
+  object: (properties: Record<string, TypeValue>): TypeValue => ({
+    kind: "object",
+    properties,
+    id: Symbol("object"),
+  }),
+  array: (element: TypeValue): TypeValue => ({ kind: "array", element }),
+  tuple: (elements: TypeValue[]): TypeValue => ({ kind: "tuple", elements }),
+  promise: (value: TypeValue): TypeValue => ({ kind: "promise", value }),
+  instanceOf: (className: string, properties: Record<string, TypeValue> = {}): TypeValue => ({
+    kind: "instance",
+    className,
+    properties,
+  }),
+  union: createUnion,
+  fn: (
+    params: string[],
+    body: Node,
+    closure: Environment,
+  ): TypeValue => ({
+    kind: "function",
+    params,
+    body,
+    closure,
+  }),
+} as const;
+
+// --- Helpers ---
+
+export function typeValueEquals(a: TypeValue, b: TypeValue): boolean {
+  if (a.kind !== b.kind) return false;
+  if (a.kind === "literal" && b.kind === "literal") return a.value === b.value;
+  if (a.kind === "primitive" && b.kind === "primitive") return a.type === b.type;
+  if (a.kind === "never" && b.kind === "never") return true;
+  if (a.kind === "unknown" && b.kind === "unknown") return true;
+  if (a.kind === "promise" && b.kind === "promise") {
+    return typeValueEquals(a.value, b.value);
+  }
+  if (a.kind === "instance" && b.kind === "instance") {
+    return a.className === b.className;
+  }
+  if (a.kind === "union" && b.kind === "union") {
+    return (
+      a.members.length === b.members.length &&
+      a.members.every((m, i) => typeValueEquals(m, b.members[i]))
+    );
+  }
+  return a === b;
+}
+
+export function simplifyUnion(members: TypeValue[]): TypeValue {
+  const flat: TypeValue[] = [];
+  for (const m of members) {
+    if (m.kind === "never") continue;
+    if (m.kind === "union") {
+      flat.push(...m.members);
+    } else {
+      flat.push(m);
+    }
+  }
+
+  const deduped: TypeValue[] = [];
+  for (const m of flat) {
+    if (!deduped.some((d) => typeValueEquals(d, m))) {
+      deduped.push(m);
+    }
+  }
+
+  if (deduped.length === 0) return T.never;
+  if (deduped.length === 1) return deduped[0];
+  if (deduped.some((m) => m.kind === "unknown")) return T.unknown;
+  return { kind: "union", members: deduped };
+}
+
+export function widenLiteral(tv: TypeValue): TypeValue {
+  if (tv.kind !== "literal") return tv;
+  const v = tv.value;
+  if (typeof v === "number") return T.number;
+  if (typeof v === "string") return T.string;
+  if (typeof v === "boolean") return T.boolean;
+  if (v === null) return T.null;
+  if (v === undefined) return T.undefined;
+  return T.unknown;
+}
+
+export function isSubtypeOf(a: TypeValue, b: TypeValue): boolean {
+  if (b.kind === "unknown") return true;
+  if (a.kind === "never") return true;
+  if (typeValueEquals(a, b)) return true;
+
+  if (a.kind === "literal" && b.kind === "primitive") {
+    const v = a.value;
+    if (b.type === "number" && typeof v === "number") return true;
+    if (b.type === "string" && typeof v === "string") return true;
+    if (b.type === "boolean" && typeof v === "boolean") return true;
+    return false;
+  }
+
+  if (a.kind === "object" && b.kind === "object") {
+    return Object.entries(b.properties).every(
+      ([k, bv]) => k in a.properties && isSubtypeOf(a.properties[k], bv),
+    );
+  }
+
+  if (a.kind === "array" && b.kind === "array") {
+    return isSubtypeOf(a.element, b.element);
+  }
+
+  if (a.kind === "tuple" && b.kind === "tuple") {
+    return (
+      a.elements.length === b.elements.length &&
+      a.elements.every((el, i) => isSubtypeOf(el, b.elements[i]))
+    );
+  }
+
+  if (a.kind === "tuple" && b.kind === "array") {
+    return a.elements.every((el) => isSubtypeOf(el, b.element));
+  }
+
+  if (a.kind === "promise" && b.kind === "promise") {
+    return isSubtypeOf(a.value, b.value);
+  }
+
+  if (a.kind === "instance" && b.kind === "instance") {
+    return a.className === b.className || isErrorSubclass(a.className, b.className);
+  }
+
+  if (a.kind === "union") {
+    return a.members.every((m) => isSubtypeOf(m, b));
+  }
+
+  if (b.kind === "union") {
+    return b.members.some((m) => isSubtypeOf(a, m));
+  }
+
+  return false;
+}
+
+const errorHierarchy: Record<string, string> = {
+  TypeError: "Error",
+  SyntaxError: "Error",
+  RangeError: "Error",
+  ReferenceError: "Error",
+  URIError: "Error",
+  EvalError: "Error",
+};
+
+function isErrorSubclass(child: string, parent: string): boolean {
+  if (child === parent) return true;
+  const sup = errorHierarchy[child];
+  return sup ? isErrorSubclass(sup, parent) : false;
+}
+
+export function deepCloneTypeValue(tv: TypeValue, idMap?: Map<symbol, symbol>): TypeValue {
+  const map = idMap ?? new Map<symbol, symbol>();
+  if (tv.kind === "object") {
+    let newId = map.get(tv.id);
+    if (!newId) {
+      newId = Symbol("object");
+      map.set(tv.id, newId);
+    }
+    const newProps: Record<string, TypeValue> = {};
+    for (const [k, v] of Object.entries(tv.properties)) {
+      newProps[k] = deepCloneTypeValue(v, map);
+    }
+    return { kind: "object", properties: newProps, id: newId };
+  }
+  if (tv.kind === "array") {
+    return { kind: "array", element: deepCloneTypeValue(tv.element, map) };
+  }
+  if (tv.kind === "tuple") {
+    return { kind: "tuple", elements: tv.elements.map((e) => deepCloneTypeValue(e, map)) };
+  }
+  if (tv.kind === "promise") {
+    return { kind: "promise", value: deepCloneTypeValue(tv.value, map) };
+  }
+  if (tv.kind === "instance") {
+    const newProps: Record<string, TypeValue> = {};
+    for (const [k, v] of Object.entries(tv.properties)) {
+      newProps[k] = deepCloneTypeValue(v, map);
+    }
+    return { kind: "instance", className: tv.className, properties: newProps };
+  }
+  if (tv.kind === "union") {
+    return simplifyUnion(tv.members.map((m) => deepCloneTypeValue(m, map)));
+  }
+  return tv;
+}
+
+export function mergeObjectProperties(
+  a: TypeValue & { kind: "object" },
+  b: TypeValue & { kind: "object" },
+): TypeValue {
+  const allKeys = new Set([...Object.keys(a.properties), ...Object.keys(b.properties)]);
+  const merged: Record<string, TypeValue> = {};
+  for (const k of allKeys) {
+    const av = a.properties[k];
+    const bv = b.properties[k];
+    if (av && bv) {
+      merged[k] = simplifyUnion([av, bv]);
+    } else {
+      merged[k] = av ?? bv;
+    }
+  }
+  return { kind: "object", properties: merged, id: a.id };
+}
+
+export function typeValueToString(tv: TypeValue): string {
+  switch (tv.kind) {
+    case "literal": {
+      const v = tv.value;
+      if (v === null) return "null";
+      if (v === undefined) return "undefined";
+      if (typeof v === "string") return JSON.stringify(v);
+      return String(v);
+    }
+    case "primitive":
+      return tv.type;
+    case "object": {
+      const entries = Object.entries(tv.properties);
+      if (entries.length === 0) return "{}";
+      const inner = entries
+        .map(([k, v]) => `${k}: ${typeValueToString(v)}`)
+        .join(", ");
+      return `{ ${inner} }`;
+    }
+    case "array":
+      return `${typeValueToString(tv.element)}[]`;
+    case "tuple": {
+      const inner = tv.elements.map(typeValueToString).join(", ");
+      return `[${inner}]`;
+    }
+    case "function": {
+      const params = tv.params.join(", ");
+      return `(${params}) => ...`;
+    }
+    case "promise":
+      return `Promise<${typeValueToString(tv.value)}>`;
+    case "instance": {
+      const entries = Object.entries(tv.properties);
+      if (entries.length === 0) return tv.className;
+      const inner = entries
+        .map(([k, v]) => `${k}: ${typeValueToString(v)}`)
+        .join(", ");
+      return `${tv.className} { ${inner} }`;
+    }
+    case "union": {
+      return tv.members.map(typeValueToString).join(" | ");
+    }
+    case "never":
+      return "never";
+    case "unknown":
+      return "unknown";
+  }
+}
+
+export function narrowType(
+  tv: TypeValue,
+  predicate: (member: TypeValue) => boolean,
+): TypeValue {
+  if (tv.kind === "union") {
+    return simplifyUnion(tv.members.filter(predicate));
+  }
+  return predicate(tv) ? tv : T.never;
+}
+
+export function subtractType(
+  tv: TypeValue,
+  predicate: (member: TypeValue) => boolean,
+): TypeValue {
+  return narrowType(tv, (m) => !predicate(m));
+}
+
+export function getPrimitiveTypeOf(tv: TypeValue): string | undefined {
+  if (tv.kind === "literal") {
+    const v = tv.value;
+    if (v === null) return "object";
+    return typeof v;
+  }
+  if (tv.kind === "primitive") return tv.type;
+  if (tv.kind === "object") return "object";
+  if (tv.kind === "array" || tv.kind === "tuple") return "object";
+  if (tv.kind === "function") return "function";
+  if (tv.kind === "promise") return "object";
+  if (tv.kind === "instance") return "object";
+  return undefined;
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}