next-openapi-gen 1.4.1 → 1.4.2

package/dist/vite/index.js

@@ -2455,23 +2455,58 @@ var SymbolResolver = class {
   }
   /**
    * Returns a simple literal value (string/number/boolean/null) for a `const` declarator,
-   * or `null` if no such declarator exists.
+   * following imports and re-exports when the name is not declared locally.
    */
   resolveLiteral(filePath, name) {
+    const visited = /* @__PURE__ */ new Set();
+    return this.resolveLiteralInternal(filePath, name, visited);
+  }
+  resolveLiteralInternal(filePath, name, visited) {
+    if (visited.has(filePath))
+      return void 0;
+    visited.add(filePath);
     const index = this.getIndex(filePath);
     if (!index)
       return void 0;
     const literal2 = index.constLiterals.get(name);
-    if (!literal2)
-      return void 0;
-    if (t3.isStringLiteral(literal2))
-      return literal2.value;
-    if (t3.isNumericLiteral(literal2))
-      return literal2.value;
-    if (t3.isBooleanLiteral(literal2))
-      return literal2.value;
-    if (t3.isNullLiteral(literal2))
-      return null;
+    if (literal2) {
+      if (t3.isStringLiteral(literal2))
+        return literal2.value;
+      if (t3.isNumericLiteral(literal2))
+        return literal2.value;
+      if (t3.isBooleanLiteral(literal2))
+        return literal2.value;
+      if (t3.isNullLiteral(literal2))
+        return null;
+    }
+    const imports = this.getImports(filePath);
+    const importInfo = imports?.get(name);
+    if (importInfo) {
+      const resolved = this.resolveImportPath(filePath, importInfo.source);
+      if (resolved) {
+        const targetName = importInfo.importedName === "default" ? name : importInfo.importedName;
+        const result = this.resolveLiteralInternal(resolved, targetName, visited);
+        if (result !== void 0)
+          return result;
+      }
+    }
+    const reExport = index.namedReExports.get(name);
+    if (reExport) {
+      const resolved = this.resolveImportPath(filePath, reExport.source);
+      if (resolved) {
+        const result = this.resolveLiteralInternal(resolved, reExport.importedName, visited);
+        if (result !== void 0)
+          return result;
+      }
+    }
+    for (const starSrc of index.exportsStar) {
+      const resolved = this.resolveImportPath(filePath, starSrc);
+      if (!resolved)
+        continue;
+      const result = this.resolveLiteralInternal(resolved, name, visited);
+      if (result !== void 0)
+        return result;
+    }
     return void 0;
   }
   /**
@@ -12794,6 +12829,58 @@ var ZodSchemaConverter = class {
       this.symbolResolver.primeAST(this.currentFilePath, this.currentAST);
     return this.symbolResolver.resolveLiteral(this.currentFilePath, name);
   }
+  /**
+   * Unwrap a possible `TSAsExpression` / `TSSatisfiesExpression` to get the
+   * underlying expression node.  Returns the node itself when no wrapper is
+   * present.
+   */
+  unwrapTypeAssertion(node) {
+    if (!node)
+      return void 0;
+    if (t10.isTSAsExpression(node) || t10.isTSSatisfiesExpression(node)) {
+      return node.expression;
+    }
+    return node;
+  }
+  /**
+   * Resolve a numeric value from a call-expression argument.
+   * Handles: numeric literals, identifier references to const numbers,
+   * and `x as number` / `x satisfies number` wrappers around either.
+   */
+  resolveNumericArg(arg) {
+    if (!arg)
+      return void 0;
+    const node = this.unwrapTypeAssertion(arg);
+    if (t10.isNumericLiteral(node))
+      return node.value;
+    if (t10.isUnaryExpression(node) && node.operator === "-" && t10.isNumericLiteral(node.argument)) {
+      return -node.argument.value;
+    }
+    if (t10.isIdentifier(node)) {
+      const val = this.resolveLiteralValue(node.name);
+      if (typeof val === "number")
+        return val;
+    }
+    return void 0;
+  }
+  /**
+   * Resolve a string value from a call-expression argument.
+   * Handles: string literals, identifier references to const strings,
+   * and `x as string` / `x satisfies string` wrappers around either.
+   */
+  resolveStringArg(arg) {
+    if (!arg)
+      return void 0;
+    const node = this.unwrapTypeAssertion(arg);
+    if (t10.isStringLiteral(node))
+      return node.value;
+    if (t10.isIdentifier(node)) {
+      const val = this.resolveLiteralValue(node.name);
+      if (typeof val === "string")
+        return val;
+    }
+    return void 0;
+  }
   /**
    * Resolve an identifier referring to a `z.object({...})` (or similar) call expression.
    * This lets callers inline the referenced object's shape.
@@ -12862,6 +12949,14 @@ var ZodSchemaConverter = class {
     if (t10.isNullLiteral(node)) {
       return null;
     }
+    if (t10.isIdentifier(node)) {
+      const val = this.resolveLiteralValue(node.name);
+      if (val !== void 0)
+        return val;
+    }
+    if (t10.isTSAsExpression(node) || t10.isTSSatisfiesExpression(node)) {
+      return this.extractStaticJsonValue(node.expression);
+    }
     if (t10.isArrayExpression(node)) {
       const values = [];
       for (const element of node.elements) {
@@ -12960,53 +13055,60 @@ var ZodSchemaConverter = class {
           schema.nullable = true;
         }
         break;
-      case "describe":
-        if (node.arguments.length > 0 && t10.isStringLiteral(node.arguments[0])) {
-          const description = node.arguments[0].value;
-          if (description.startsWith("@deprecated")) {
+      case "describe": {
+        const descVal = this.resolveStringArg(node.arguments[0]);
+        if (descVal !== void 0) {
+          if (descVal.startsWith("@deprecated")) {
             schema.deprecated = true;
-            schema.description = description.replace("@deprecated", "").trim();
+            schema.description = descVal.replace("@deprecated", "").trim();
           } else {
-            schema.description = description;
+            schema.description = descVal;
           }
         }
         break;
+      }
       case "deprecated":
         schema.deprecated = true;
         break;
-      case "min":
-        if (node.arguments.length > 0 && t10.isNumericLiteral(node.arguments[0])) {
+      case "min": {
+        const minVal = this.resolveNumericArg(node.arguments[0]);
+        if (minVal !== void 0) {
           if (schema.type === "string") {
-            schema.minLength = node.arguments[0].value;
+            schema.minLength = minVal;
           } else if (schema.type === "number" || schema.type === "integer") {
-            schema.minimum = node.arguments[0].value;
+            schema.minimum = minVal;
           } else if (schema.type === "array") {
-            schema.minItems = node.arguments[0].value;
+            schema.minItems = minVal;
           }
         }
         break;
-      case "max":
-        if (node.arguments.length > 0 && t10.isNumericLiteral(node.arguments[0])) {
+      }
+      case "max": {
+        const maxVal = this.resolveNumericArg(node.arguments[0]);
+        if (maxVal !== void 0) {
           if (schema.type === "string") {
-            schema.maxLength = node.arguments[0].value;
+            schema.maxLength = maxVal;
           } else if (schema.type === "number" || schema.type === "integer") {
-            schema.maximum = node.arguments[0].value;
+            schema.maximum = maxVal;
           } else if (schema.type === "array") {
-            schema.maxItems = node.arguments[0].value;
+            schema.maxItems = maxVal;
           }
         }
         break;
-      case "length":
-        if (node.arguments.length > 0 && t10.isNumericLiteral(node.arguments[0])) {
+      }
+      case "length": {
+        const lenVal = this.resolveNumericArg(node.arguments[0]);
+        if (lenVal !== void 0) {
           if (schema.type === "string") {
-            schema.minLength = node.arguments[0].value;
-            schema.maxLength = node.arguments[0].value;
+            schema.minLength = lenVal;
+            schema.maxLength = lenVal;
           } else if (schema.type === "array") {
-            schema.minItems = node.arguments[0].value;
-            schema.maxItems = node.arguments[0].value;
+            schema.minItems = lenVal;
+            schema.maxItems = lenVal;
           }
         }
         break;
+      }
       case "nonempty":
         if (schema.type === "array") {
           schema.minItems = Math.max(schema.minItems ?? 0, 1);
@@ -13082,21 +13184,27 @@ var ZodSchemaConverter = class {
           schema.pattern = node.arguments[0].pattern;
         }
         break;
-      case "startsWith":
-        if (node.arguments.length > 0 && t10.isStringLiteral(node.arguments[0])) {
-          schema.pattern = `^${this.escapeRegExp(node.arguments[0].value)}`;
+      case "startsWith": {
+        const swVal = this.resolveStringArg(node.arguments[0]);
+        if (swVal !== void 0) {
+          schema.pattern = `^${this.escapeRegExp(swVal)}`;
         }
         break;
-      case "endsWith":
-        if (node.arguments.length > 0 && t10.isStringLiteral(node.arguments[0])) {
-          schema.pattern = `${this.escapeRegExp(node.arguments[0].value)}$`;
+      }
+      case "endsWith": {
+        const ewVal = this.resolveStringArg(node.arguments[0]);
+        if (ewVal !== void 0) {
+          schema.pattern = `${this.escapeRegExp(ewVal)}$`;
         }
         break;
-      case "includes":
-        if (node.arguments.length > 0 && t10.isStringLiteral(node.arguments[0])) {
-          schema.pattern = this.escapeRegExp(node.arguments[0].value);
+      }
+      case "includes": {
+        const incVal = this.resolveStringArg(node.arguments[0]);
+        if (incVal !== void 0) {
+          schema.pattern = this.escapeRegExp(incVal);
         }
         break;
+      }
       case "int":
         schema.type = "integer";
         break;
@@ -13120,17 +13228,22 @@ var ZodSchemaConverter = class {
         break;
       case "default":
         if (node.arguments.length > 0) {
-          if (t10.isStringLiteral(node.arguments[0])) {
-            schema.default = node.arguments[0].value;
-          } else if (t10.isNumericLiteral(node.arguments[0])) {
-            schema.default = node.arguments[0].value;
-          } else if (t10.isBooleanLiteral(node.arguments[0])) {
-            schema.default = node.arguments[0].value;
-          } else if (t10.isNullLiteral(node.arguments[0])) {
+          const defaultArg = this.unwrapTypeAssertion(node.arguments[0]);
+          if (t10.isStringLiteral(defaultArg)) {
+            schema.default = defaultArg.value;
+          } else if (t10.isNumericLiteral(defaultArg)) {
+            schema.default = defaultArg.value;
+          } else if (t10.isBooleanLiteral(defaultArg)) {
+            schema.default = defaultArg.value;
+          } else if (t10.isNullLiteral(defaultArg)) {
             schema.default = null;
-          } else if (t10.isObjectExpression(node.arguments[0])) {
+          } else if (t10.isIdentifier(defaultArg)) {
+            const val = this.resolveLiteralValue(defaultArg.name);
+            if (val !== void 0)
+              schema.default = val;
+          } else if (t10.isObjectExpression(defaultArg)) {
             const defaultObj = {};
-            node.arguments[0].properties.forEach((prop) => {
+            defaultArg.properties.forEach((prop) => {
               if (t10.isObjectProperty(prop) && (t10.isIdentifier(prop.key) || t10.isStringLiteral(prop.key)) && (t10.isStringLiteral(prop.value) || t10.isNumericLiteral(prop.value) || t10.isBooleanLiteral(prop.value))) {
                 const key = t10.isIdentifier(prop.key) ? prop.key.name : prop.key.value;
                 const value = t10.isStringLiteral(prop.value) ? prop.value.value : t10.isNumericLiteral(prop.value) ? prop.value.value : t10.isBooleanLiteral(prop.value) ? prop.value.value : null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-openapi-gen",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "Automatically generate OpenAPI 3.0, 3.1, and 3.2 documentation from Next.js projects, with support for Zod schemas, TypeScript types, and reusable OpenAPI fragments.",
   "keywords": [
     "api",