@nudojs/env 0.2.4 → 0.3.0

package/dist/chunk-MW5NHORB.js

@@ -0,0 +1,402 @@
+// src/es.ts
+import {
+  litValue,
+  numLit,
+  strLit as strLit2,
+  boolLit
+} from "@nudojs/core";
+
+// src/abs-helpers.ts
+import {
+  abs as makeAbs,
+  lit as termLit,
+  absFunction,
+  relationFn,
+  relationFingerprint,
+  objOf,
+  num,
+  str,
+  strLit,
+  bool,
+  never,
+  unknown
+} from "@nudojs/core";
+var dummyBody = {
+  type: "BlockStatement",
+  body: [],
+  directives: []
+};
+function undef() {
+  return makeAbs({ k: "unknown" }, termLit(void 0), void 0, "exact");
+}
+function nullLit() {
+  return makeAbs({ k: "unknown" }, termLit(null), void 0, "exact");
+}
+function anyAbs() {
+  return makeAbs({ k: "any" }, void 0, void 0, "path");
+}
+function arrOf(element) {
+  return makeAbs({ k: "arr", element }, void 0, void 0, "exact");
+}
+function tupleOf(elements, rest) {
+  const shape = rest ? { k: "tuple", elements, rest } : { k: "tuple", elements };
+  return makeAbs(shape, void 0, void 0, "exact");
+}
+function unionOf(...members) {
+  if (members.length === 0) return never;
+  if (members.length === 1) return members[0];
+  return makeAbs({ k: "sum", members }, void 0, void 0, "exact");
+}
+function promiseOf(inner) {
+  return makeAbs({ k: "eff", eff: "promise", inner }, void 0, void 0, "exact");
+}
+function brandOf(name, shape = unknown) {
+  return makeAbs({ k: "brand", name, shape }, void 0, void 0, "path");
+}
+function errorBrandOf(name) {
+  return makeAbs(
+    {
+      k: "brand",
+      name,
+      shape: objOf({
+        name: { value: strLit(name) },
+        message: { value: str() }
+      })
+    },
+    void 0,
+    void 0,
+    "path"
+  );
+}
+function envFn(paramTypes, returnType, apply, opts) {
+  const params = opts?.params ?? paramTypes.map((_, i) => paramTypes.length === 1 && i === 0 ? "x" : `x${i}`);
+  if (!apply) {
+    return relationFn(paramTypes, returnType, {
+      params,
+      conf: opts?.conf ?? "exact",
+      fingerprint: opts?.name ? `${opts.name}|${relationFingerprint(paramTypes, returnType)}` : void 0
+    });
+  }
+  const implApply = apply;
+  const a = absFunction(params, {
+    body: dummyBody,
+    apply: (args) => {
+      try {
+        const r = implApply(args);
+        return r ?? returnType;
+      } catch {
+        return returnType;
+      }
+    }
+  });
+  a.shape = {
+    k: "fn",
+    params,
+    paramTypes,
+    returnType,
+    ...opts?.name ? { name: opts.name } : {}
+  };
+  if (opts?.conf && opts.conf !== "exact") a.conf = opts.conf;
+  return a;
+}
+function slotsOf(entries) {
+  const out = {};
+  for (const [k, v] of Object.entries(entries)) {
+    out[k] = v && typeof v === "object" && "value" in v && !("shape" in v) ? v : { value: v };
+  }
+  return out;
+}
+function objAbs(entries) {
+  return objOf(slotsOf(entries));
+}
+var prim = {
+  num,
+  str,
+  bool,
+  never,
+  unknown,
+  undef,
+  nullLit,
+  any: anyAbs
+};
+
+// src/es.ts
+function absNumLit(a) {
+  if (!a) return void 0;
+  const v = litValue(a);
+  return typeof v === "number" ? v : void 0;
+}
+function absStrLit(a) {
+  if (!a) return void 0;
+  const v = litValue(a);
+  return typeof v === "string" ? v : void 0;
+}
+function numImpl1Abs(fn) {
+  return (args) => {
+    const a = absNumLit(args[0]);
+    return a !== void 0 ? numLit(fn(a)) : void 0;
+  };
+}
+function numImpl2Abs(fn) {
+  return (args) => {
+    const a = absNumLit(args[0]);
+    const b = absNumLit(args[1]);
+    return a !== void 0 && b !== void 0 ? numLit(fn(a, b)) : void 0;
+  };
+}
+function strToStrImplAbs(fn) {
+  return (args) => {
+    const s = absStrLit(args[0]);
+    return s !== void 0 ? strLit2(fn(s)) : void 0;
+  };
+}
+function defineEnv() {
+  const voidFn = envFn([prim.unknown], undef());
+  const consoleSlots = {};
+  for (const name of [
+    "log",
+    "error",
+    "warn",
+    "info",
+    "debug",
+    "trace",
+    "dir",
+    "table",
+    "time",
+    "timeEnd",
+    "timeLog",
+    "clear",
+    "count",
+    "countReset",
+    "group",
+    "groupCollapsed",
+    "groupEnd",
+    "assert"
+  ]) {
+    consoleSlots[name] = voidFn;
+  }
+  const jsonStringifyImplAbs = (args) => {
+    const a = args[0];
+    if (!a) return void 0;
+    const v = litValue(a);
+    if (v === void 0 && a.term?.op !== "lit") return void 0;
+    try {
+      const result = JSON.stringify(v);
+      return result === void 0 ? undef() : strLit2(result);
+    } catch {
+      return void 0;
+    }
+  };
+  const parseIntImplAbs = (args) => {
+    const s = absStrLit(args[0]);
+    if (s === void 0) return void 0;
+    if (args[1] === void 0) return numLit(parseInt(s));
+    const radix = absNumLit(args[1]);
+    if (radix === void 0) return void 0;
+    if (!Number.isInteger(radix) || radix < 2 || radix > 36) return numLit(NaN);
+    return numLit(parseInt(s, radix));
+  };
+  const parseFloatImplAbs = (args) => {
+    const s = absStrLit(args[0]);
+    if (s !== void 0) return numLit(parseFloat(s));
+    return void 0;
+  };
+  const isNaNImplAbs = (args) => {
+    const n = absNumLit(args[0]);
+    return n !== void 0 ? boolLit(Number.isNaN(n)) : void 0;
+  };
+  const isFiniteImplAbs = (args) => {
+    const n = absNumLit(args[0]);
+    return n !== void 0 ? boolLit(Number.isFinite(n)) : void 0;
+  };
+  const isIntegerImplAbs = (args) => {
+    const n = absNumLit(args[0]);
+    return n !== void 0 ? boolLit(Number.isInteger(n)) : void 0;
+  };
+  const isSafeIntegerImplAbs = (args) => {
+    const n = absNumLit(args[0]);
+    return n !== void 0 ? boolLit(Number.isSafeInteger(n)) : void 0;
+  };
+  const booleanImplAbs = (args) => {
+    const a = args[0];
+    if (!a) return void 0;
+    const v = litValue(a);
+    if (v === void 0 && a.term?.op !== "lit") return void 0;
+    return boolLit(Boolean(v));
+  };
+  const stringImplAbs = (args) => {
+    const a = args[0];
+    if (!a) return void 0;
+    const v = litValue(a);
+    if (v === null || v === void 0) return void 0;
+    return strLit2(String(v));
+  };
+  const isArrayImplAbs = (args) => {
+    const a = args[0];
+    if (!a) return void 0;
+    let s = a.shape;
+    while (s.k === "brand") s = s.shape.shape;
+    if (s.k === "arr" || s.k === "tuple") return boolLit(true);
+    if (s.k === "prim" || s.k === "obj" || s.k === "eff") return boolLit(false);
+    if (a.term?.op === "lit") return boolLit(false);
+    return void 0;
+  };
+  const promiseResolveImplAbs = (args) => {
+    if (!args[0]) return void 0;
+    return promiseOf(args[0]);
+  };
+  return {
+    globals: {
+      JSON: objAbs({
+        parse: envFn([prim.str()], prim.unknown),
+        stringify: envFn(
+          [prim.unknown],
+          unionOf(prim.str(), undef()),
+          jsonStringifyImplAbs
+        )
+      }),
+      Math: objAbs({
+        abs: envFn([prim.num()], prim.num(), numImpl1Abs(Math.abs)),
+        ceil: envFn([prim.num()], prim.num(), numImpl1Abs(Math.ceil)),
+        floor: envFn([prim.num()], prim.num(), numImpl1Abs(Math.floor)),
+        round: envFn([prim.num()], prim.num(), numImpl1Abs(Math.round)),
+        trunc: envFn([prim.num()], prim.num(), numImpl1Abs(Math.trunc)),
+        sign: envFn([prim.num()], prim.num(), numImpl1Abs(Math.sign)),
+        max: envFn([prim.num(), prim.num()], prim.num(), numImpl2Abs(Math.max)),
+        min: envFn([prim.num(), prim.num()], prim.num(), numImpl2Abs(Math.min)),
+        pow: envFn([prim.num(), prim.num()], prim.num(), numImpl2Abs(Math.pow)),
+        sqrt: envFn([prim.num()], prim.num(), numImpl1Abs(Math.sqrt)),
+        cbrt: envFn([prim.num()], prim.num(), numImpl1Abs(Math.cbrt)),
+        log: envFn([prim.num()], prim.num(), numImpl1Abs(Math.log)),
+        log2: envFn([prim.num()], prim.num(), numImpl1Abs(Math.log2)),
+        log10: envFn([prim.num()], prim.num(), numImpl1Abs(Math.log10)),
+        exp: envFn([prim.num()], prim.num(), numImpl1Abs(Math.exp)),
+        random: envFn([], prim.num()),
+        sin: envFn([prim.num()], prim.num(), numImpl1Abs(Math.sin)),
+        cos: envFn([prim.num()], prim.num(), numImpl1Abs(Math.cos)),
+        tan: envFn([prim.num()], prim.num(), numImpl1Abs(Math.tan)),
+        asin: envFn([prim.num()], prim.num(), numImpl1Abs(Math.asin)),
+        acos: envFn([prim.num()], prim.num(), numImpl1Abs(Math.acos)),
+        atan: envFn([prim.num()], prim.num(), numImpl1Abs(Math.atan)),
+        atan2: envFn([prim.num(), prim.num()], prim.num(), numImpl2Abs(Math.atan2)),
+        hypot: envFn([prim.num(), prim.num()], prim.num(), numImpl2Abs(Math.hypot)),
+        clz32: envFn([prim.num()], prim.num(), numImpl1Abs(Math.clz32)),
+        imul: envFn([prim.num(), prim.num()], prim.num(), numImpl2Abs(Math.imul)),
+        fround: envFn([prim.num()], prim.num(), numImpl1Abs(Math.fround)),
+        PI: prim.num(),
+        E: prim.num(),
+        LN2: prim.num(),
+        LN10: prim.num(),
+        LOG2E: prim.num(),
+        LOG10E: prim.num(),
+        SQRT2: prim.num(),
+        SQRT1_2: prim.num()
+      }),
+      Number: objAbs({
+        isFinite: envFn([prim.unknown], prim.bool(), isFiniteImplAbs),
+        isInteger: envFn([prim.unknown], prim.bool(), isIntegerImplAbs),
+        isNaN: envFn([prim.unknown], prim.bool(), isNaNImplAbs),
+        isSafeInteger: envFn([prim.unknown], prim.bool(), isSafeIntegerImplAbs),
+        parseFloat: envFn([prim.str()], prim.num(), parseFloatImplAbs),
+        parseInt: envFn([prim.str()], prim.num(), parseIntImplAbs),
+        MAX_SAFE_INTEGER: prim.num(),
+        MIN_SAFE_INTEGER: prim.num(),
+        MAX_VALUE: prim.num(),
+        MIN_VALUE: prim.num(),
+        POSITIVE_INFINITY: prim.num(),
+        NEGATIVE_INFINITY: prim.num(),
+        NaN: prim.num(),
+        EPSILON: prim.num()
+      }),
+      Boolean: envFn([prim.unknown], prim.bool(), booleanImplAbs),
+      String: envFn([prim.unknown], prim.str(), stringImplAbs),
+      Array: objAbs({
+        isArray: envFn([prim.unknown], prim.bool(), isArrayImplAbs),
+        from: envFn([prim.unknown], arrOf(prim.unknown)),
+        of: envFn([prim.unknown], arrOf(prim.unknown))
+      }),
+      console: objAbs(consoleSlots),
+      parseInt: envFn([prim.str(), prim.num()], prim.num(), parseIntImplAbs),
+      parseFloat: envFn([prim.str()], prim.num(), parseFloatImplAbs),
+      isNaN: envFn([prim.unknown], prim.bool(), isNaNImplAbs),
+      isFinite: envFn([prim.unknown], prim.bool(), isFiniteImplAbs),
+      encodeURI: envFn([prim.str()], prim.str(), strToStrImplAbs(encodeURI)),
+      decodeURI: envFn([prim.str()], prim.str(), strToStrImplAbs(decodeURI)),
+      encodeURIComponent: envFn(
+        [prim.str()],
+        prim.str(),
+        strToStrImplAbs(encodeURIComponent)
+      ),
+      decodeURIComponent: envFn(
+        [prim.str()],
+        prim.str(),
+        strToStrImplAbs(decodeURIComponent)
+      ),
+      Error: envFn([prim.str()], errorBrandOf("Error")),
+      TypeError: envFn([prim.str()], errorBrandOf("TypeError")),
+      RangeError: envFn([prim.str()], errorBrandOf("RangeError")),
+      SyntaxError: envFn([prim.str()], errorBrandOf("SyntaxError")),
+      ReferenceError: envFn([prim.str()], errorBrandOf("ReferenceError")),
+      URIError: envFn([prim.str()], errorBrandOf("URIError")),
+      Promise: objAbs({
+        resolve: envFn([prim.unknown], promiseOf(prim.unknown), promiseResolveImplAbs),
+        reject: envFn([prim.unknown], promiseOf(prim.never)),
+        all: envFn([arrOf(promiseOf(prim.unknown))], promiseOf(arrOf(prim.unknown))),
+        allSettled: envFn(
+          [arrOf(promiseOf(prim.unknown))],
+          promiseOf(arrOf(prim.unknown))
+        ),
+        race: envFn([arrOf(promiseOf(prim.unknown))], promiseOf(prim.unknown)),
+        any: envFn([arrOf(promiseOf(prim.unknown))], promiseOf(prim.unknown))
+      }),
+      Date: objAbs({
+        now: envFn([], prim.num()),
+        parse: envFn([prim.str()], prim.num()),
+        UTC: envFn([prim.num(), prim.num()], prim.num())
+      }),
+      Symbol: envFn([prim.str()], brandOf("Symbol")),
+      Reflect: objAbs({
+        apply: envFn(
+          [prim.unknown, prim.unknown, arrOf(prim.unknown)],
+          prim.unknown
+        ),
+        construct: envFn([prim.unknown, arrOf(prim.unknown)], prim.unknown),
+        defineProperty: envFn(
+          [prim.unknown, prim.str(), prim.unknown],
+          prim.bool()
+        ),
+        deleteProperty: envFn([prim.unknown, prim.str()], prim.bool()),
+        get: envFn([prim.unknown, prim.str()], prim.unknown),
+        getOwnPropertyDescriptor: envFn(
+          [prim.unknown, prim.str()],
+          unionOf(prim.unknown, undef())
+        ),
+        getPrototypeOf: envFn([prim.unknown], unionOf(prim.unknown, nullLit())),
+        has: envFn([prim.unknown, prim.str()], prim.bool()),
+        isExtensible: envFn([prim.unknown], prim.bool()),
+        ownKeys: envFn([prim.unknown], arrOf(prim.str())),
+        preventExtensions: envFn([prim.unknown], prim.bool()),
+        set: envFn([prim.unknown, prim.str(), prim.unknown], prim.bool()),
+        setPrototypeOf: envFn([prim.unknown, prim.unknown], prim.bool())
+      }),
+      globalThis: prim.unknown,
+      undefined: undef(),
+      NaN: prim.num(),
+      Infinity: prim.num()
+    }
+  };
+}
+
+export {
+  undef,
+  nullLit,
+  arrOf,
+  tupleOf,
+  unionOf,
+  promiseOf,
+  brandOf,
+  envFn,
+  objAbs,
+  prim,
+  defineEnv
+};

package/dist/es.d.ts

@@ -1,8 +1,13 @@
-import { TypeValue } from '@nudojs/core';
+import { Abs } from '@nudojs/core';
+
+/**
+ * ES env：Abs 原生 globals。
+ * EnvDefinition.globals / modules 均为 Abs。
+ */
 
 type EnvDefinition = {
-    globals: Record<string, TypeValue>;
-    modules?: Record<string, Record<string, TypeValue>>;
+    globals: Record<string, Abs>;
+    modules?: Record<string, Record<string, Abs>>;
 };
 declare function defineEnv(): EnvDefinition;
 

package/dist/es.js

@@ -1,6 +1,6 @@
 import {
   defineEnv
-} from "./chunk-VBTQ36SR.js";
+} from "./chunk-MW5NHORB.js";
 export {
   defineEnv
 };

package/dist/node.d.ts

@@ -1,6 +1,10 @@
 import { EnvDefinition } from './es.js';
 import '@nudojs/core';
 
+/**
+ * Node env：es globals + node 内建 modules（Abs 原生）。
+ */
+
 declare function defineEnv(): EnvDefinition;
 
 export { EnvDefinition, defineEnv };