@nudojs/cli 0.3.0 → 0.4.0

package/src/builtins/builtin-prototype.ts

@@ -1,279 +0,0 @@
-/**
- * 内置类原型机制：错误类集合、可构造内置类、Object/Array/Map/Set/…/Buffer
- * 的原型成员近似表，以及 `X.prototype` 单例与类命名空间记忆化。
- * 求值器成员分派与补全侧成员派生共用本表的唯一真值。
- */
-
-import { T, simplifyUnion, type TypeValue } from "@nudojs/core";
-import { MAP_INSTANCE_METHODS, mapEntriesIterable } from "./builtin-map.ts";
-import { SET_INSTANCE_METHODS } from "./builtin-set.ts";
-
-// hasOwnProp 守卫：普通 Record 表查找会从原型链泄漏原生函数（如 "constructor"）。
-// 与 evaluator 内同名 helper 同语义；独立副本避免 evaluator → 本模块循环依赖。
-function hasOwnProp(props: Record<string, unknown>, name: string): boolean {
-  return Object.prototype.hasOwnProperty.call(props, name);
-}
-
-const BUILTIN_ERROR_CLASSES = new Set([
-  "Error", "TypeError", "SyntaxError", "RangeError", "ReferenceError", "URIError", "EvalError",
-]);
-// Constructible built-in classes. A bare reference to one of these names
-// resolves to a namespace object (like the BUILTIN_STATIC_METHODS entries),
-// and `X.prototype` evaluates to an instance of X instead of degrading to
-// undefined/unknown.
-const BUILTIN_PROTOTYPE_CLASSES = new Set([
-  ...BUILTIN_ERROR_CLASSES,
-  "Date", "Object", "Map", "Set", "Promise", "RegExp", "Array", "Function",
-  "String", "Number", "Boolean", "Symbol", "WeakMap", "WeakSet", "Buffer",
-]);
-// Object.prototype members. Real property access reads through the
-// prototype chain, so every object-typed receiver materializes these —
-// destructuring `const { hasOwnProperty } = obj` yields a function (not
-// undefined) and `Object.prototype.hasOwnProperty` types as boolean.
-// Lookup must be own-property guarded: a plain `{}` record would otherwise
-// leak native JS functions (e.g. for "constructor") into the type system.
-//
-// toString/valueOf carry impls so the receiver (thisVal) shapes the result:
-// `Object.prototype.toString.call(x)` yields the brand literal
-// ('[object Map]', '[object Null]', ...) that Map-based type dispatch
-// (hoek internals.typeMap) keys on; valueOf returns its receiver.
-const OBJECT_PROTOTYPE_METHODS: Record<string, TypeValue> = {
-  hasOwnProperty: T.fnSig([T.unknown], T.boolean),
-  isPrototypeOf: T.fnSig([T.unknown], T.boolean),
-  propertyIsEnumerable: T.fnSig([T.unknown], T.boolean),
-  toString: T.fnSig([], T.string, T.never, (_args, thisVal) => objectToStringBrand(thisVal)),
-  toLocaleString: T.fnSig([], T.string),
-  valueOf: T.fnSig([], T.unknown, T.never, (_args, thisVal) => thisVal),
-};
-// Common prototype members approximated as unknown-result signatures
-// (mirrors the knownInstanceMethods fallback pattern). `X.prototype.m`
-// stays a callable function value instead of degrading to undefined.
-const BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS: Record<string, Record<string, TypeValue>> = {
-  Object: { ...OBJECT_PROTOTYPE_METHODS },
-  Array: {
-    push: T.fnSig([T.unknown], T.number),
-    pop: T.fnSig([], T.unknown),
-    shift: T.fnSig([], T.unknown),
-    unshift: T.fnSig([T.unknown], T.number),
-    slice: T.fnSig([T.number, T.number], T.array(T.unknown)),
-    splice: T.fnSig([T.number, T.number], T.array(T.unknown)),
-    concat: T.fnSig([T.unknown], T.array(T.unknown)),
-    join: T.fnSig([T.string], T.string),
-    indexOf: T.fnSig([T.unknown], T.number),
-    lastIndexOf: T.fnSig([T.unknown], T.number),
-    includes: T.fnSig([T.unknown], T.boolean),
-    map: T.fnSig([T.unknown], T.array(T.unknown)),
-    flatMap: T.fnSig([T.unknown], T.array(T.unknown)),
-    filter: T.fnSig([T.unknown], T.array(T.unknown)),
-    forEach: T.fnSig([T.unknown], T.undefined),
-    find: T.fnSig([T.unknown], T.unknown),
-    findIndex: T.fnSig([T.unknown], T.number),
-    some: T.fnSig([T.unknown], T.boolean),
-    every: T.fnSig([T.unknown], T.boolean),
-    reduce: T.fnSig([T.unknown, T.unknown], T.unknown),
-    sort: T.fnSig([T.unknown], T.array(T.unknown)),
-    reverse: T.fnSig([], T.array(T.unknown)),
-    toString: T.fnSig([], T.string),
-  },
-  Function: {
-    call: T.fnSig([T.unknown], T.unknown),
-    apply: T.fnSig([T.unknown, T.unknown], T.unknown),
-    bind: T.fnSig([T.unknown], T.unknown),
-    toString: T.fnSig([], T.string),
-  },
-  Map: {
-    // Impl-routed: `Map.prototype.m.call(instance)` (and direct prototype
-    // calls) consult the receiver's exact entry side table, making the
-    // hoek deepEqual reflection idioms decide literally.
-    get: T.fnSig([T.unknown], T.unknown, T.never, (args, thisVal) => MAP_INSTANCE_METHODS.get(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    set: T.fnSig([T.unknown, T.unknown], T.unknown, T.never, (args, thisVal) => MAP_INSTANCE_METHODS.set(args[0] ?? T.unknown, args[1] ?? T.unknown, thisVal ?? T.unknown)),
-    has: T.fnSig([T.unknown], T.boolean, T.never, (args, thisVal) => MAP_INSTANCE_METHODS.has(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    delete: T.fnSig([T.unknown], T.boolean, T.never, (args, thisVal) => MAP_INSTANCE_METHODS.delete(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    clear: T.fnSig([], T.undefined, T.never, (args, thisVal) => MAP_INSTANCE_METHODS.clear(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    forEach: T.fnSig([T.unknown], T.undefined),
-    keys: T.fnSig([], T.array(T.unknown), T.never, (_args, thisVal) => MAP_INSTANCE_METHODS.keys(thisVal ?? T.unknown)),
-    values: T.fnSig([], T.array(T.unknown), T.never, (_args, thisVal) => MAP_INSTANCE_METHODS.values(thisVal ?? T.unknown)),
-    entries: T.fnSig([], T.array(T.tuple([T.unknown, T.unknown])), T.never, (_args, thisVal) => mapEntriesIterable(thisVal ?? T.unknown)),
-    toString: T.fnSig([], T.string),
-  },
-  Set: {
-    // Impl-routed like Map above (Set.prototype.values.call(s) ≡ s.values()).
-    add: T.fnSig([T.unknown], T.unknown, T.never, (args, thisVal) => SET_INSTANCE_METHODS.add(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    has: T.fnSig([T.unknown], T.boolean, T.never, (args, thisVal) => SET_INSTANCE_METHODS.has(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    delete: T.fnSig([T.unknown], T.boolean, T.never, (args, thisVal) => SET_INSTANCE_METHODS.delete(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    clear: T.fnSig([], T.undefined, T.never, (args, thisVal) => SET_INSTANCE_METHODS.clear(args[0] ?? T.unknown, thisVal ?? T.unknown)),
-    forEach: T.fnSig([T.unknown], T.undefined),
-    keys: T.fnSig([], T.array(T.unknown), T.never, (_args, thisVal) => SET_INSTANCE_METHODS.keys(thisVal ?? T.unknown)),
-    values: T.fnSig([], T.array(T.unknown), T.never, (_args, thisVal) => SET_INSTANCE_METHODS.values(thisVal ?? T.unknown)),
-    entries: T.fnSig([], T.array(T.tuple([T.unknown, T.unknown])), T.never, (_args, thisVal) => SET_INSTANCE_METHODS.entries(thisVal ?? T.unknown)),
-    toString: T.fnSig([], T.string),
-  },
-  WeakMap: {
-    get: T.fnSig([T.unknown], T.unknown),
-    set: T.fnSig([T.unknown, T.unknown], T.unknown),
-    has: T.fnSig([T.unknown], T.boolean),
-    delete: T.fnSig([T.unknown], T.boolean),
-    toString: T.fnSig([], T.string),
-  },
-  WeakSet: {
-    add: T.fnSig([T.unknown], T.unknown),
-    has: T.fnSig([T.unknown], T.boolean),
-    delete: T.fnSig([T.unknown], T.boolean),
-    toString: T.fnSig([], T.string),
-  },
-  Promise: {
-    then: T.fnSig([T.unknown], T.promise(T.unknown)),
-    catch: T.fnSig([T.unknown], T.promise(T.unknown)),
-    finally: T.fnSig([T.unknown], T.promise(T.unknown)),
-    toString: T.fnSig([], T.string),
-  },
-  Date: {
-    getTime: T.fnSig([], T.number),
-    valueOf: T.fnSig([], T.number),
-    toISOString: T.fnSig([], T.string),
-    toJSON: T.fnSig([], T.string),
-    toLocaleString: T.fnSig([], T.string),
-    toString: T.fnSig([], T.string),
-  },
-  RegExp: {
-    test: T.fnSig([T.string], T.boolean),
-    exec: T.fnSig([T.string], T.union(T.object({}), T.null)),
-    toString: T.fnSig([], T.string),
-  },
-  String: {
-    charAt: T.fnSig([T.number], T.string),
-    charCodeAt: T.fnSig([T.number], T.number),
-    indexOf: T.fnSig([T.string], T.number),
-    lastIndexOf: T.fnSig([T.string], T.number),
-    includes: T.fnSig([T.string], T.boolean),
-    startsWith: T.fnSig([T.string], T.boolean),
-    endsWith: T.fnSig([T.string], T.boolean),
-    slice: T.fnSig([T.number, T.number], T.string),
-    substring: T.fnSig([T.number, T.number], T.string),
-    toUpperCase: T.fnSig([], T.string),
-    toLowerCase: T.fnSig([], T.string),
-    trim: T.fnSig([], T.string),
-    replace: T.fnSig([T.unknown, T.string], T.string),
-    split: T.fnSig([T.string], T.array(T.string)),
-    toString: T.fnSig([], T.string),
-    valueOf: T.fnSig([], T.string),
-  },
-  Number: {
-    toFixed: T.fnSig([T.number], T.string),
-    toPrecision: T.fnSig([T.number], T.string),
-    valueOf: T.fnSig([], T.number),
-    toString: T.fnSig([T.number], T.string),
-  },
-  Boolean: {
-    valueOf: T.fnSig([], T.boolean),
-    toString: T.fnSig([], T.string),
-  },
-  Symbol: {
-    toString: T.fnSig([], T.string),
-    valueOf: T.fnSig([], T.symbol),
-  },
-  Buffer: {
-    equals: T.fnSig([T.unknown], T.boolean),
-    compare: T.fnSig([T.unknown], T.number),
-    toString: T.fnSig([T.unknown], T.string),
-    toJSON: T.fnSig([], T.unknown),
-  },
-  Error: {
-    toString: T.fnSig([], T.string),
-  },
-};
-// Memoized namespace values for built-in classes. Reference-stable so
-// `'x'.constructor === String` compares identical objects (typeValueEquals
-// falls back to reference equality for object kinds).
-const _builtinClassValues = new Map<string, TypeValue>();
-function builtinClassValue(name: string): TypeValue {
-  let v = _builtinClassValues.get(name);
-  if (v === undefined) {
-    v = T.object({});
-    (v as any)._builtinName = name;
-    _builtinClassValues.set(name, v);
-  }
-  return v;
-}
-// Cached `X.prototype` singletons. hoek-style modules assign
-// `exports.array = Array.prototype` and later compare
-// `baseProto === Types.buffer`: strict-equality on instances only stays
-// precise when every evaluation of `X.prototype` yields the same TypeValue.
-const BUILTIN_PROTOTYPE_SINGLETONS = new Map<string, TypeValue>();
-
-function builtinPrototype(className: string): TypeValue {
-  let proto = BUILTIN_PROTOTYPE_SINGLETONS.get(className);
-  if (!proto) {
-    const methods = hasOwnProp(BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS, className)
-      ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS[className]
-      : BUILTIN_ERROR_CLASSES.has(className)
-        ? BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS.Error
-        : {};
-    proto = T.instanceOf(className, { ...methods });
-    (proto as any)._builtinProto = className;
-    BUILTIN_PROTOTYPE_SINGLETONS.set(className, proto);
-  }
-  return proto;
-}
-// `Object.prototype.toString` brand string ('[object Map]', '[object Null]',
-// ...). Returns undefined when the receiver has no representable brand, so
-// the fnSig falls back to its plain `string` return type.
-function objectToStringBrand(v: TypeValue | undefined): TypeValue | undefined {
-  if (!v) return undefined;
-  if (v.kind === "union") {
-    const parts = v.members.map((m) => objectToStringBrand(m));
-    if (parts.some((p) => p === undefined)) return undefined;
-    return simplifyUnion(parts as TypeValue[]);
-  }
-  let base: TypeValue = v;
-  while (base.kind === "refined") base = base.base;
-  switch (base.kind) {
-    case "object": return T.literal("[object Object]");
-    case "array":
-    case "tuple": return T.literal("[object Array]");
-    case "function": return T.literal("[object Function]");
-    case "promise": return T.literal("[object Promise]");
-    case "instance": return T.literal(`[object ${base.className}]`);
-    case "literal": {
-      if (base.value === null) return T.literal("[object Null]");
-      if (base.value === undefined) return T.literal("[object Undefined]");
-      const t = typeof base.value;
-      return T.literal(`[object ${t === "number" ? "Number" : t === "string" ? "String" : "Boolean"}]`);
-    }
-    case "primitive": {
-      const brands: Record<string, string> = {
-        number: "Number", string: "String", boolean: "Boolean", bigint: "BigInt", symbol: "Symbol",
-      };
-      return T.literal(`[object ${brands[base.type] ?? "Object"}]`);
-    }
-    default: return undefined;
-  }
-}
-// Object.getPrototypeOf: map a receiver onto its class's cached prototype
-// singleton (plain objects → Object.prototype, arrays → Array.prototype,
-// instances → their class's prototype). Unrepresentable receivers degrade
-// to unknown.
-function protoOfValue(v: TypeValue | undefined): TypeValue {
-  if (!v) return T.unknown;
-  if (v.kind === "union") return simplifyUnion(v.members.map((m) => protoOfValue(m)));
-  let base: TypeValue = v;
-  while (base.kind === "refined") base = base.base;
-  switch (base.kind) {
-    case "object": return builtinPrototype("Object");
-    case "array":
-    case "tuple": return builtinPrototype("Array");
-    case "function": return builtinPrototype("Function");
-    case "promise": return builtinPrototype("Promise");
-    case "instance": return builtinPrototype(base.className);
-    default: return T.unknown;
-  }
-}
-export {
-  BUILTIN_ERROR_CLASSES,
-  BUILTIN_PROTOTYPE_CLASSES,
-  OBJECT_PROTOTYPE_METHODS,
-  BUILTIN_PROTOTYPE_METHOD_APPROXIMATIONS,
-  builtinClassValue,
-  builtinPrototype,
-  protoOfValue,
-};

package/src/builtins/builtin-reflect.ts

@@ -1,30 +0,0 @@
-import { type TypeValue, T } from "@nudojs/core";
-
-export const REFLECT_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  has: () => T.boolean,
-  get: () => T.unknown,
-  set: () => T.boolean,
-  deleteProperty: () => T.boolean,
-  apply: () => T.unknown,
-  construct: () => T.object({}),
-  // Shape-aware like Object.keys: known receivers list their declared
-  // own-property names (hoek's Utils.keys → clone/flatten key loops then
-  // iterate concrete keys instead of a symbolic string), arrays add the
-  // non-enumerable "length" own key. Unknown shapes keep the approximation.
-  ownKeys: (target?: TypeValue) => {
-    let base = target;
-    while (base?.kind === "refined") base = base.base;
-    if (base && (base.kind === "object" || base.kind === "instance")) {
-      return T.tuple(Object.keys(base.properties).map((k) => T.literal(k)));
-    }
-    if (base?.kind === "tuple") {
-      return T.tuple([
-        ...base.elements.map((_, i) => T.literal(String(i))),
-        T.literal("length"),
-      ]);
-    }
-    return T.array(T.string);
-  },
-  getPrototypeOf: () => T.union(T.object({}), T.null),
-  getOwnPropertyDescriptor: () => T.union(T.object({}), T.undefined),
-};

package/src/builtins/builtin-regexp.ts

@@ -1,34 +0,0 @@
-import { type TypeValue, T } from "@nudojs/core";
-
-export const REGEXP_INSTANCE_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  test: () => T.boolean,
-  exec: () => T.union(T.null, T.object({})),
-  toString: () => T.string,
-};
-
-export const REGEXP_PROPS: Record<string, TypeValue> = {
-  source: T.string,
-  flags: T.string,
-  global: T.boolean,
-  ignoreCase: T.boolean,
-  multiline: T.boolean,
-  dotAll: T.boolean,
-  unicode: T.boolean,
-  sticky: T.boolean,
-};
-
-export function createRegExpType(): TypeValue {
-  return T.instanceOf("RegExp", {
-    source: T.string,
-    flags: T.string,
-    global: T.boolean,
-    ignoreCase: T.boolean,
-    multiline: T.boolean,
-    dotAll: T.boolean,
-    unicode: T.boolean,
-    sticky: T.boolean,
-    test: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    exec: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-    toString: T.fn(["...args"], { type: "BlockStatement", body: [] } as any, undefined as any),
-  });
-}

package/src/builtins/builtin-set.ts

@@ -1,131 +0,0 @@
-import { type TypeValue, T, simplifyUnion, typeValueEquals } from "@nudojs/core";
-
-// Literal/instance values recorded at construction (`new Set([a, b])`) or
-// via add() — precise enough for typeValueEquals lookup in has(). Symbolic
-// values are skipped and has() falls back to boolean.
-function valueTrackable(v: TypeValue | undefined): boolean {
-  return v?.kind === "literal" || v?.kind === "instance";
-}
-
-// Union values distribute: every member present → true, none present →
-// false, mixed/not comparable → null (symbolic boolean fallback).
-function lookupValues(values: TypeValue[], value: TypeValue): boolean | null {
-  if (value.kind === "union") {
-    const results = value.members.map((m) => lookupValues(values, m));
-    if (results.some((r) => r === null)) return null;
-    return results.some((r) => r === true) && results.every((r) => r === true);
-  }
-  if (!valueTrackable(value)) return null;
-  return values.some((v) => typeValueEquals(v, value));
-}
-
-export const SET_INSTANCE_METHODS: Record<string, (...args: TypeValue[]) => TypeValue> = {
-  add: (value: TypeValue, set?: TypeValue) => {
-    if (set) {
-      const typeArgs = (set as any)._typeArgs || { T: T.unknown };
-      (set as any)._typeArgs = {
-        T: typeArgs.T.kind === "unknown" ? value : simplifyUnion([typeArgs.T, value]),
-      };
-      if (valueTrackable(value)) {
-        // An exact list can start on the first trackable add (nothing
-        // untracked came before); once partial it stays partial.
-        if ((set as any)._values === undefined && (set as any)._valuesExact !== false) {
-          (set as any)._values = [];
-          (set as any)._valuesExact = true;
-        }
-        if ((set as any)._valuesExact) {
-          const values = (set as any)._values as TypeValue[];
-          if (!values.some((v) => typeValueEquals(v, value))) values.push(value);
-        }
-      } else {
-        (set as any)._valuesExact = false;
-      }
-    }
-    return set ?? T.unknown;
-  },
-  has: (value: TypeValue, set?: TypeValue) => {
-    const values = exactSetValues(set);
-    if (values) {
-      const looked = lookupValues(values, value);
-      if (looked !== null) return T.literal(looked);
-    }
-    return T.boolean;
-  },
-  delete: (value: TypeValue, set?: TypeValue) => {
-    const values = exactSetValues(set);
-    if (values && valueTrackable(value)) {
-      const idx = values.findIndex((v) => typeValueEquals(v, value));
-      if (idx >= 0) {
-        values.splice(idx, 1);
-        return T.literal(true);
-      }
-      return T.literal(false);
-    }
-    return T.boolean;
-  },
-  clear: (value?: TypeValue, set?: TypeValue) => {
-    // s.clear() arrives as clear(receiver): the set sits in the first
-    // param slot when the call has no arguments.
-    const target = set ?? value;
-    if (target && (target as any)._valuesExact) {
-      (target as any)._values = [];
-    }
-    return T.undefined;
-  },
-  forEach: () => T.undefined,
-  values: (set?: TypeValue) => setValuesIterable(set),
-  // For Set, keys() is the same as values()
-  keys: (set?: TypeValue) => setValuesIterable(set),
-  entries: (set?: TypeValue) => {
-    const values = exactSetValues(set);
-    if (values) return T.tuple(values.map((v) => T.tuple([v, v])));
-    const typeArgs = (set as any)?._typeArgs;
-    if (typeArgs?.T) return T.array(T.tuple([typeArgs.T, typeArgs.T]));
-    return T.array(T.tuple([T.unknown, T.unknown]));
-  },
-};
-
-// Exact membership side table: present only when every member seen so far
-// (construction elements + adds) was trackable. Partial tables must not
-// decide has()/delete()/iteration — an untracked member could be anything.
-export function exactSetValues(set: TypeValue | undefined): TypeValue[] | undefined {
-  if (!set || (set as any)._valuesExact !== true) return undefined;
-  return (set as any)._values as TypeValue[] | undefined;
-}
-
-// values()/keys() keep feeding `new Set(...)`-style consumers: a tuple of
-// the exact members when the side table is complete, else array<T>.
-export function setValuesIterable(set: TypeValue | undefined): TypeValue {
-  const values = exactSetValues(set);
-  if (values) return T.tuple([...values]);
-  const typeArgs = (set as any)?._typeArgs;
-  if (typeArgs?.T) return T.array(typeArgs.T);
-  return T.array(T.unknown);
-}
-
-export function createSetType(args?: TypeValue[]): TypeValue {
-  const obj = T.instanceOf("Set", {});
-
-  if (args && args.length > 0) {
-    const arg = args[0];
-    if (arg.kind === "tuple" || arg.kind === "array") {
-      const elements = arg.kind === "tuple" ? arg.elements : [arg.element];
-      (obj as any)._typeArgs = { T: simplifyUnion(elements) };
-      // Only a fully trackable element list is exact: symbolic elements
-      // mean the recorded values are a subset of the real membership.
-      const exact = elements.every(valueTrackable);
-      if (exact && elements.length > 0) {
-        (obj as any)._values = elements;
-        (obj as any)._valuesExact = true;
-      } else if (!exact) {
-        (obj as any)._valuesExact = false;
-      }
-    }
-  }
-
-  if (!(obj as any)._typeArgs) {
-    (obj as any)._typeArgs = { T: T.unknown };
-  }
-
-  return obj;
-}