@nudojs/parser 0.5.1 → 1.0.0

package/dist/index.d.ts

@@ -18,7 +18,7 @@ declare function parse(source: string, opts?: {
 type CaseDirective = {
     kind: "case";
     name: string;
-    /** 无损参数 Abs（case 文法唯一真理源；约束表达式与 T.* 均产出） */
+    /** 无损参数 Abs（case 文法唯一真理源：约束构建器 / 具体字面量） */
     argsAbs: Abs[];
     /** `=> expected` 断言 Abs */
     expected?: Abs;
@@ -82,14 +82,12 @@ type FunctionWithDirectives = {
     directives: Directive[];
 };
 /**
- * case 实参主路径：始终产出 Abs；约束表达式优先。
- * `T.*` 文法 **已弃用**，仅为旧 fixture 兼容保留——新代码用 `number()`/`lit()`。
+ * case 实参 / 指令类型表达式唯一文法：约束构建器优先，其余为具体字面量、
+ * 结构字面量与箭头函数。`T.*` 文法已物理删除。
  */
 declare function parseCaseArgExpr(expr: string): Abs;
-/** @deprecated 旧名兼容；等价 parseCaseArgExpr */
-declare function parseTypeValueExpr(expr: string): Abs;
 declare function extractDirectives(ast: Node): FunctionWithDirectives[];
 declare function extractInlineDirectives(node: Node): InlineDirective[];
 declare function extractFileDirectives(ast: Node): FileDirective[];
 
-export { type AsDirective, type CaseDirective, type Directive, type EnvDirective, type FileDirective, type FunctionWithDirectives, type InlineDirective, type MockDirective, type MockModuleDirective, type PureDirective, type ReplaceDirective, type SampleDirective, type SinonExpression, type SkipDirective, extractDirectives, extractFileDirectives, extractInlineDirectives, parse, parseCaseArgExpr, parseTypeValueExpr };
+export { type AsDirective, type CaseDirective, type Directive, type EnvDirective, type FileDirective, type FunctionWithDirectives, type InlineDirective, type MockDirective, type MockModuleDirective, type PureDirective, type ReplaceDirective, type SampleDirective, type SinonExpression, type SkipDirective, extractDirectives, extractFileDirectives, extractInlineDirectives, parse, parseCaseArgExpr };

package/dist/index.js

@@ -14,9 +14,6 @@ import {
   mock,
   abs as makeAbs,
   lit as termLit,
-  num,
-  str,
-  bool,
   numLit,
   strLit,
   boolLit,
@@ -46,17 +43,13 @@ function absLit(v) {
   if (v === null) return absNullLit();
   return absUndefLit();
 }
-function absUnion(members) {
-  if (members.length === 0) return absExact({ k: "never" });
-  return members.reduce((acc, m) => joinAbs(acc, m));
-}
 var CASE_NAME_REGEX = /@nudo:case\s+"([^"]+)"\s*\(/g;
 var MOCK_INLINE_REGEX = /@nudo:mock\s+(\w+)\s*=\s*(.+)/g;
 var MOCK_FROM_REGEX = /@nudo:mock\s+(\w+)\s+from\s+"([^"]+)"/g;
 var PURE_REGEX = /@nudo:pure\b/g;
 var SKIP_REGEX = /@nudo:skip(?:\s+(.+))?/g;
 var SAMPLE_REGEX = /@nudo:sample\s+(\d+)/g;
-var CONSTRAINT_EXPR_RE = /^(number|string|boolean|array|shape|lit|union|fn|partial|pick|omit|record|required|readonly|nonNullable|and)\s*\(/;
+var CONSTRAINT_EXPR_RE = /^(number|string|boolean|any|array|shape|lit|union|fn|partial|pick|omit|record|required|readonly|nonNullable|and)\s*\(/;
 function tryParseConstraint(expr) {
   const s = expr.trim();
   if (!CONSTRAINT_EXPR_RE.test(s)) return void 0;
@@ -85,15 +78,15 @@ function flattenPreds(preds) {
 function constraintSelfEqLit(c, selfIds) {
   const leaves = flattenPreds(c.preds);
   const eqs = leaves.filter((p2) => p2.op === "eq");
-  if (eqs.length !== 1) return void 0;
+  if (eqs.length !== 1) return { found: false };
   const p = eqs[0];
-  if (p.op !== "eq") return void 0;
+  if (p.op !== "eq") return { found: false };
   const isSelf = (t) => t.op === "var" && typeof t.id === "string" && selfIds.includes(t.id);
   const a = p.a;
   const b = p.b;
-  if (isSelf(a) && b.op === "lit") return b.value;
-  if (isSelf(b) && a.op === "lit") return a.value;
-  return void 0;
+  if (isSelf(a) && b.op === "lit") return { found: true, value: b.value };
+  if (isSelf(b) && a.op === "lit") return { found: true, value: a.value };
+  return { found: false };
 }
 function constraintToCaseArgAbs(c) {
   if (c.members && c.members.length > 0) {
@@ -102,10 +95,32 @@ function constraintToCaseArgAbs(c) {
     return { shape: { k: "sum", members: parts }, conf: "path" };
   }
   const selfIds = [SELF, "__arg", "__nudo_self__"];
-  const lv = constraintSelfEqLit(c, selfIds);
-  if (typeof lv === "number" && !Number.isNaN(lv)) return numLit(lv);
-  if (typeof lv === "string") return strLit(lv);
-  if (typeof lv === "boolean") return boolLit(lv);
+  const litRes = constraintSelfEqLit(c, selfIds);
+  if (litRes.found) {
+    const lv = litRes.value;
+    if (typeof lv === "number" && !Number.isNaN(lv)) return numLit(lv);
+    if (typeof lv === "string") return strLit(lv);
+    if (typeof lv === "boolean") return boolLit(lv);
+    if (lv === null) return absNullLit();
+    return absUndefLit();
+  }
+  if (c.element) {
+    return absExact({ k: "arr", element: constraintToCaseArgAbs(c.element) });
+  }
+  if (c.fields) {
+    const slots = {};
+    for (const [key, field] of Object.entries(c.fields)) {
+      slots[key] = { value: constraintToCaseArgAbs(field.constraint) };
+    }
+    return absExact({ k: "obj", slots });
+  }
+  const bareScalar = !c.fields && !c.element && !c.members && !c.fn && c.int !== true && c.preds.length === 0;
+  if (bareScalar) {
+    if (c.prim === "number" || c.prim === "string" || c.prim === "boolean") {
+      return absExact({ k: "prim", type: c.prim });
+    }
+    if (!c.prim) return absUnknown();
+  }
   return constraintToEntryAbs(c, "__arg");
 }
 function parseCaseArgExpr(expr) {
@@ -117,52 +132,16 @@ function parseCaseArgExpr(expr) {
       return absUnknown();
     }
   }
-  return parseLegacyTypeExpr(expr);
-}
-function parseTypeValueExpr(expr) {
-  return parseCaseArgExpr(expr);
+  return parseLiteralOrStructure(expr);
 }
-function parseLegacyTypeExpr(expr) {
+function parseLiteralOrStructure(expr) {
   const s = expr.trim();
-  if (s === "T.number") return num();
-  if (s === "T.string") return str();
-  if (s === "T.boolean") return bool();
-  if (s === "T.unknown") return absUnknown();
-  if (s === "T.never") return absExact({ k: "never" });
-  if (s === "T.null") return absNullLit();
-  if (s === "T.undefined") return absUndefLit();
   if (s === "true") return absLit(true);
   if (s === "false") return absLit(false);
   if (s === "null") return absLit(null);
   if (s === "undefined") return absLit(void 0);
-  const literalMatch = s.match(/^T\.literal\((.+)\)$/);
-  if (literalMatch) {
-    return absLit(parsePrimitiveValue(literalMatch[1].trim()));
-  }
-  if (s.startsWith("T.union(") && s.endsWith(")")) {
-    const inner = s.slice("T.union(".length, -1);
-    const args = splitTopLevelArgs(inner);
-    return absUnion(args.map(parseLegacyTypeExpr));
-  }
-  if (s.startsWith("T.array(") && s.endsWith(")")) {
-    const inner = s.slice("T.array(".length, -1);
-    return absExact({ k: "arr", element: parseLegacyTypeExpr(inner) });
-  }
-  if (s.startsWith("T.tuple(") && s.endsWith(")")) {
-    const inner = s.slice("T.tuple(".length, -1).trim();
-    if (inner.startsWith("[") && inner.endsWith("]")) {
-      const elements = splitTopLevelArgs(inner.slice(1, -1));
-      return absExact({ k: "tuple", elements: elements.map(parseLegacyTypeExpr) });
-    }
-    return absExact({ k: "tuple", elements: [] });
-  }
-  if (s.startsWith("T.object(") && s.endsWith(")")) {
-    const inner = s.slice("T.object(".length, -1).trim();
-    if (inner.startsWith("{") && inner.endsWith("}")) {
-      return parseObjectLiteral(inner.slice(1, -1).trim());
-    }
-    return absExact({ k: "obj", slots: {} });
-  }
+  if (s === "unknown" || s === "any") return absUnknown();
+  if (s === "never") return absExact({ k: "never" });
   if (findTopLevelArrow(s) !== -1 || /^function\s*[\w$]*\s*\(/.test(s)) {
     const fnExpr = parseArrowFunctionExpr(s);
     if (fnExpr) {
@@ -180,7 +159,7 @@ function parseLegacyTypeExpr(expr) {
     const content = s.slice(1, -1).trim();
     if (!content) return absExact({ k: "tuple", elements: [] });
     const elements = splitTopLevelArgs(content);
-    return absExact({ k: "tuple", elements: elements.map(parseLegacyTypeExpr) });
+    return absExact({ k: "tuple", elements: elements.map((e) => parseCaseArgExpr(e)) });
   }
   return absUnknown();
 }
@@ -193,21 +172,10 @@ function parseObjectLiteral(content) {
     if (colonIdx === -1) continue;
     const key = entry.slice(0, colonIdx).trim().replace(/^["']|["']$/g, "");
     const val = entry.slice(colonIdx + 1).trim();
-    slots[key] = { value: parseLegacyTypeExpr(val) };
+    slots[key] = { value: parseCaseArgExpr(val) };
   }
   return absExact({ k: "obj", slots });
 }
-function parsePrimitiveValue(s) {
-  if (s === "true") return true;
-  if (s === "false") return false;
-  if (s === "null") return null;
-  if (s === "undefined") return void 0;
-  if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
-  if (s.startsWith('"') && s.endsWith('"') || s.startsWith("'") && s.endsWith("'")) {
-    return s.slice(1, -1);
-  }
-  return s;
-}
 function splitTopLevelArgs(s) {
   const result = [];
   let depth = 0;
@@ -622,7 +590,7 @@ function findReplaceSeparator(raw) {
     }
     if (ch === " " && depth === 0) {
       const rest = raw.slice(i + 1).trimStart();
-      if (rest.startsWith("T.") || rest.startsWith("{") || rest.startsWith("[") || rest.startsWith('"') || rest.startsWith("'") || /^-?\d/.test(rest) || rest === "true" || rest === "false" || rest === "null" || rest === "undefined") {
+      if (CONSTRAINT_EXPR_RE.test(rest) || rest.startsWith("{") || rest.startsWith("[") || rest.startsWith('"') || rest.startsWith("'") || rest === "true" || rest === "false" || rest === "null" || rest === "undefined" || rest === "unknown" || rest === "any" || rest === "never" || /^-?\d+(\.\d+)?$/.test(rest) || rest.includes("=>") || /^function\s*[\w$]*\s*\(/.test(rest)) {
         return i;
       }
     }
@@ -673,6 +641,5 @@ export {
   extractInlineDirectives,
   parse,
   parseCaseArgExpr,
-  parseTypeValueExpr,
   stripTypes
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudojs/parser",
-  "version": "0.5.1",
+  "version": "1.0.0",
   "engines": {
     "node": ">=20"
   },
@@ -39,7 +39,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@nudojs/core": "2.0.1"
+    "@nudojs/core": "2.1.0"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts"