@nudojs/core 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @nudojs/core
+
+## 0.1.0
+
+### Minor Changes
+
+- Conceptual design and basic implementation.

package/dist/index.d.ts

@@ -0,0 +1,104 @@
+import { Node } from '@babel/types';
+
+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>;
+};
+declare function createEnvironment(parent?: Environment, bindings?: Map<string, TypeValue>): Environment;
+
+type LiteralValue = string | number | boolean | null | undefined;
+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";
+};
+declare function createUnion(...members: TypeValue[]): TypeValue;
+declare const T: {
+    readonly literal: (value: LiteralValue) => TypeValue;
+    readonly number: TypeValue;
+    readonly string: TypeValue;
+    readonly boolean: TypeValue;
+    readonly bigint: TypeValue;
+    readonly symbol: TypeValue;
+    readonly null: TypeValue;
+    readonly undefined: TypeValue;
+    readonly unknown: TypeValue;
+    readonly never: TypeValue;
+    readonly object: (properties: Record<string, TypeValue>) => TypeValue;
+    readonly array: (element: TypeValue) => TypeValue;
+    readonly tuple: (elements: TypeValue[]) => TypeValue;
+    readonly promise: (value: TypeValue) => TypeValue;
+    readonly instanceOf: (className: string, properties?: Record<string, TypeValue>) => TypeValue;
+    readonly union: typeof createUnion;
+    readonly fn: (params: string[], body: Node, closure: Environment) => TypeValue;
+};
+declare function typeValueEquals(a: TypeValue, b: TypeValue): boolean;
+declare function simplifyUnion(members: TypeValue[]): TypeValue;
+declare function widenLiteral(tv: TypeValue): TypeValue;
+declare function isSubtypeOf(a: TypeValue, b: TypeValue): boolean;
+declare function deepCloneTypeValue(tv: TypeValue, idMap?: Map<symbol, symbol>): TypeValue;
+declare function mergeObjectProperties(a: TypeValue & {
+    kind: "object";
+}, b: TypeValue & {
+    kind: "object";
+}): TypeValue;
+declare function typeValueToString(tv: TypeValue): string;
+declare function narrowType(tv: TypeValue, predicate: (member: TypeValue) => boolean): TypeValue;
+declare function subtractType(tv: TypeValue, predicate: (member: TypeValue) => boolean): TypeValue;
+declare function getPrimitiveTypeOf(tv: TypeValue): string | undefined;
+
+declare const Ops: {
+    readonly add: (left: TypeValue, right: TypeValue) => TypeValue;
+    readonly sub: (left: TypeValue, right: TypeValue) => TypeValue;
+    readonly mul: (left: TypeValue, right: TypeValue) => TypeValue;
+    readonly div: (left: TypeValue, right: TypeValue) => TypeValue;
+    readonly mod: (left: TypeValue, right: TypeValue) => TypeValue;
+    readonly strictEq: (left: TypeValue, right: TypeValue) => TypeValue;
+    readonly strictNeq: (left: TypeValue, right: TypeValue) => TypeValue;
+    readonly gt: (left: TypeValue, right: TypeValue) => TypeValue;
+    readonly lt: (left: TypeValue, right: TypeValue) => TypeValue;
+    readonly gte: (left: TypeValue, right: TypeValue) => TypeValue;
+    readonly lte: (left: TypeValue, right: TypeValue) => TypeValue;
+    readonly typeof_: (operand: TypeValue) => TypeValue;
+    readonly not: (operand: TypeValue) => TypeValue;
+    readonly neg: (operand: TypeValue) => TypeValue;
+};
+declare function applyBinaryOp(op: string, left: TypeValue, right: TypeValue): TypeValue;
+
+export { type Environment, type LiteralValue, Ops, T, type TypeValue, applyBinaryOp, createEnvironment, deepCloneTypeValue, getPrimitiveTypeOf, isSubtypeOf, mergeObjectProperties, narrowType, simplifyUnion, subtractType, typeValueEquals, typeValueToString, widenLiteral };

package/dist/index.js

@@ -0,0 +1,440 @@
+// src/type-value.ts
+function createUnion(...members) {
+  return simplifyUnion(members);
+}
+var T = {
+  literal: (value) => ({ kind: "literal", value }),
+  number: { kind: "primitive", type: "number" },
+  string: { kind: "primitive", type: "string" },
+  boolean: { kind: "primitive", type: "boolean" },
+  bigint: { kind: "primitive", type: "bigint" },
+  symbol: { kind: "primitive", type: "symbol" },
+  null: { kind: "literal", value: null },
+  undefined: { kind: "literal", value: void 0 },
+  unknown: { kind: "unknown" },
+  never: { kind: "never" },
+  object: (properties) => ({
+    kind: "object",
+    properties,
+    id: Symbol("object")
+  }),
+  array: (element) => ({ kind: "array", element }),
+  tuple: (elements) => ({ kind: "tuple", elements }),
+  promise: (value) => ({ kind: "promise", value }),
+  instanceOf: (className, properties = {}) => ({
+    kind: "instance",
+    className,
+    properties
+  }),
+  union: createUnion,
+  fn: (params, body, closure) => ({
+    kind: "function",
+    params,
+    body,
+    closure
+  })
+};
+function typeValueEquals(a, b) {
+  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;
+}
+function simplifyUnion(members) {
+  const flat = [];
+  for (const m of members) {
+    if (m.kind === "never") continue;
+    if (m.kind === "union") {
+      flat.push(...m.members);
+    } else {
+      flat.push(m);
+    }
+  }
+  const deduped = [];
+  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 };
+}
+function widenLiteral(tv) {
+  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 === void 0) return T.undefined;
+  return T.unknown;
+}
+function isSubtypeOf(a, b) {
+  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;
+}
+var errorHierarchy = {
+  TypeError: "Error",
+  SyntaxError: "Error",
+  RangeError: "Error",
+  ReferenceError: "Error",
+  URIError: "Error",
+  EvalError: "Error"
+};
+function isErrorSubclass(child, parent) {
+  if (child === parent) return true;
+  const sup = errorHierarchy[child];
+  return sup ? isErrorSubclass(sup, parent) : false;
+}
+function deepCloneTypeValue(tv, idMap) {
+  const map = idMap ?? /* @__PURE__ */ new Map();
+  if (tv.kind === "object") {
+    let newId = map.get(tv.id);
+    if (!newId) {
+      newId = Symbol("object");
+      map.set(tv.id, newId);
+    }
+    const newProps = {};
+    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 = {};
+    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;
+}
+function mergeObjectProperties(a, b) {
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(a.properties), ...Object.keys(b.properties)]);
+  const merged = {};
+  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 };
+}
+function typeValueToString(tv) {
+  switch (tv.kind) {
+    case "literal": {
+      const v = tv.value;
+      if (v === null) return "null";
+      if (v === void 0) 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";
+  }
+}
+function narrowType(tv, predicate) {
+  if (tv.kind === "union") {
+    return simplifyUnion(tv.members.filter(predicate));
+  }
+  return predicate(tv) ? tv : T.never;
+}
+function subtractType(tv, predicate) {
+  return narrowType(tv, (m) => !predicate(m));
+}
+function getPrimitiveTypeOf(tv) {
+  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 void 0;
+}
+
+// src/ops.ts
+function bothLiteral(l, r) {
+  if (l.kind === "literal" && r.kind === "literal") {
+    return { lv: l.value, rv: r.value };
+  }
+  return null;
+}
+var Ops = {
+  add(left, right) {
+    const lit = bothLiteral(left, right);
+    if (lit) {
+      return T.literal(lit.lv + lit.rv);
+    }
+    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, right) {
+    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, right) {
+    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, right) {
+    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, right) {
+    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, right) {
+    const lit = bothLiteral(left, right);
+    if (lit) return T.literal(lit.lv === lit.rv);
+    return T.boolean;
+  },
+  strictNeq(left, right) {
+    const lit = bothLiteral(left, right);
+    if (lit) return T.literal(lit.lv !== lit.rv);
+    return T.boolean;
+  },
+  gt(left, right) {
+    const lit = bothLiteral(left, right);
+    if (lit) return T.literal(lit.lv > lit.rv);
+    return T.boolean;
+  },
+  lt(left, right) {
+    const lit = bothLiteral(left, right);
+    if (lit) return T.literal(lit.lv < lit.rv);
+    return T.boolean;
+  },
+  gte(left, right) {
+    const lit = bothLiteral(left, right);
+    if (lit) return T.literal(lit.lv >= lit.rv);
+    return T.boolean;
+  },
+  lte(left, right) {
+    const lit = bothLiteral(left, right);
+    if (lit) return T.literal(lit.lv <= lit.rv);
+    return T.boolean;
+  },
+  typeof_(operand) {
+    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) {
+    if (operand.kind === "literal") return T.literal(!operand.value);
+    return T.boolean;
+  },
+  neg(operand) {
+    if (operand.kind === "literal" && typeof operand.value === "number") {
+      return T.literal(-operand.value);
+    }
+    return T.number;
+  }
+};
+var binaryOpMap = {
+  "+": Ops.add,
+  "-": Ops.sub,
+  "*": Ops.mul,
+  "/": Ops.div,
+  "%": Ops.mod,
+  "===": Ops.strictEq,
+  "!==": Ops.strictNeq,
+  ">": Ops.gt,
+  "<": Ops.lt,
+  ">=": Ops.gte,
+  "<=": Ops.lte
+};
+function applyBinaryOp(op, left, right) {
+  const fn = binaryOpMap[op];
+  if (!fn) return T.unknown;
+  return fn(left, right);
+}
+
+// src/environment.ts
+function createEnvironment(parent, bindings = /* @__PURE__ */ new Map()) {
+  const store = new Map(bindings);
+  const env = {
+    lookup(name) {
+      const val = store.get(name);
+      if (val !== void 0) 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 = /* @__PURE__ */ new Map();
+      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 = {};
+      for (const [k, v] of store) {
+        result[k] = v;
+      }
+      return result;
+    }
+  };
+  return env;
+}
+export {
+  Ops,
+  T,
+  applyBinaryOp,
+  createEnvironment,
+  deepCloneTypeValue,
+  getPrimitiveTypeOf,
+  isSubtypeOf,
+  mergeObjectProperties,
+  narrowType,
+  simplifyUnion,
+  subtractType,
+  typeValueEquals,
+  typeValueToString,
+  widenLiteral
+};

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@nudojs/core",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts"
+  }
+}

package/src/__tests__/environment.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect } from "vitest";
+import { createEnvironment } from "../environment.ts";
+import { T, typeValueEquals } from "../type-value.ts";
+
+describe("Environment", () => {
+  it("binds and looks up values", () => {
+    const env = createEnvironment();
+    env.bind("x", T.literal(42));
+    expect(typeValueEquals(env.lookup("x"), T.literal(42))).toBe(true);
+  });
+
+  it("returns undefined for unbound names", () => {
+    const env = createEnvironment();
+    expect(typeValueEquals(env.lookup("x"), T.undefined)).toBe(true);
+  });
+
+  it("extends with child scope", () => {
+    const parent = createEnvironment();
+    parent.bind("x", T.literal(1));
+    const child = parent.extend({ y: T.literal(2) });
+    expect(typeValueEquals(child.lookup("x"), T.literal(1))).toBe(true);
+    expect(typeValueEquals(child.lookup("y"), T.literal(2))).toBe(true);
+  });
+
+  it("child binding shadows parent", () => {
+    const parent = createEnvironment();
+    parent.bind("x", T.literal(1));
+    const child = parent.extend({ x: T.literal(99) });
+    expect(typeValueEquals(child.lookup("x"), T.literal(99))).toBe(true);
+    expect(typeValueEquals(parent.lookup("x"), T.literal(1))).toBe(true);
+  });
+
+  it("has checks existence", () => {
+    const env = createEnvironment();
+    expect(env.has("x")).toBe(false);
+    env.bind("x", T.number);
+    expect(env.has("x")).toBe(true);
+  });
+
+  it("snapshot creates independent copy", () => {
+    const env = createEnvironment();
+    env.bind("x", T.literal(1));
+    const snap = env.snapshot();
+    env.bind("x", T.literal(2));
+    expect(typeValueEquals(snap.lookup("x"), T.literal(1))).toBe(true);
+    expect(typeValueEquals(env.lookup("x"), T.literal(2))).toBe(true);
+  });
+});