@umijs/zod2ts 4.0.59 → 4.0.61

package/README.md

@@ -0,0 +1,3 @@
+# @umijs/zod2ts
+
+See our website [umijs](https://umijs.org) for more information.

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { zodToTs } from './zod';

package/dist/index.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  zodToTs: () => import_zod.zodToTs
+});
+module.exports = __toCommonJS(src_exports);
+var import_zod = require("./zod");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  zodToTs
+});

package/dist/types.d.ts

@@ -0,0 +1,8 @@
+import type { ZodTypeAny } from '@umijs/utils/compiled/zod';
+export declare type LiteralType = string | number | boolean;
+export declare type ZodToTsOptions = {};
+export interface IZodToTsOpts {
+    zod: ZodTypeAny;
+    identifier?: string;
+    options?: ZodToTsOptions;
+}

package/dist/types.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/zod.d.ts

@@ -0,0 +1,2 @@
+import { IZodToTsOpts } from './types';
+export declare const zodToTs: (opts: IZodToTsOpts) => string;

package/dist/zod.js

@@ -0,0 +1,234 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/zod.ts
+var zod_exports = {};
+__export(zod_exports, {
+  zodToTs: () => zodToTs
+});
+module.exports = __toCommonJS(zod_exports);
+var zodToTs = (opts) => {
+  const { zod, identifier = "Identifier", options = {} } = opts;
+  const { typeName } = zod == null ? void 0 : zod._def;
+  const props = { identifier, options };
+  switch (typeName) {
+    case "ZodString":
+      return "string";
+    case "ZodNumber":
+      return "number";
+    case "ZodBigInt":
+      return "bigint";
+    case "ZodBoolean":
+      return "boolean";
+    case "ZodDate":
+      return "Date";
+    case "ZodUndefined":
+      return "undefined";
+    case "ZodNull":
+      return "null";
+    case "ZodVoid":
+      return "(void | undefined)";
+    case "ZodAny":
+      return "any";
+    case "ZodUnknown":
+      return "unknown";
+    case "ZodNever":
+      return "never";
+    case "ZodLazy": {
+      return "any";
+    }
+    case "ZodLiteral": {
+      let literal;
+      const literalValue = zod._def.value;
+      switch (typeof literalValue) {
+        case "number":
+          literal = "number";
+          break;
+        case "boolean":
+          if (literalValue === true) {
+            literal = "true";
+          } else {
+            literal = "false";
+          }
+          break;
+        default:
+          literal = `"${literalValue}"`;
+          break;
+      }
+      return literal;
+    }
+    case "ZodObject": {
+      const properties = Object.entries(zod._def.shape());
+      const members = properties.map(([key, value]) => {
+        const nextZodNode = value;
+        const type = zodToTs({
+          zod: nextZodNode,
+          ...props
+        });
+        const { typeName: nextZodNodeTypeName } = nextZodNode._def;
+        const isOptional = nextZodNodeTypeName === "ZodOptional" || nextZodNode.isOptional();
+        let desc;
+        if (nextZodNode.description) {
+          desc = nextZodNode.description;
+        }
+        if (key.includes("-")) {
+          key = `"${key}"`;
+        }
+        if (isOptional) {
+          key = `${key}?`;
+        }
+        return [key, type, desc];
+      });
+      return `{
+${members.map(([key, type, desc]) => {
+        return [
+          (desc == null ? void 0 : desc.length) && `    /** ${desc} */`,
+          /*           */
+          `    ${key}: ${type};`
+        ].filter(Boolean).join("\n");
+      }).join("\n")}
+}`;
+    }
+    case "ZodArray": {
+      const type = zodToTs({ zod: zod._def.type, ...props });
+      const node = `Array<${type}>`;
+      return node;
+    }
+    case "ZodEnum": {
+      const types = zod._def.values.map((value) => {
+        return `"${value}"`;
+      });
+      const union = types.join(" | ");
+      return union;
+    }
+    case "ZodUnion": {
+      const options2 = zod._def.options;
+      const types = options2.map((option) => zodToTs({ zod: option }));
+      return types.join(" | ");
+    }
+    case "ZodDiscriminatedUnion": {
+      const options2 = [...zod._def.options.values()];
+      const types = options2.map(
+        (option) => zodToTs({ zod: option, ...props })
+      );
+      return types.join(" | ");
+    }
+    case "ZodEffects": {
+      const node = zodToTs({
+        zod: zod._def.schema,
+        ...props
+      });
+      return node;
+    }
+    case "ZodNativeEnum": {
+      return "any";
+    }
+    case "ZodOptional": {
+      const innerType = zodToTs({
+        zod: zod._def.innerType,
+        ...props
+      });
+      return `(${innerType} | undefined)`;
+    }
+    case "ZodNullable": {
+      const innerType = zodToTs({
+        zod: zod._def.innerType,
+        ...props
+      });
+      return `(${innerType} | null)`;
+    }
+    case "ZodTuple": {
+      const types = zod._def.items.map(
+        (option) => zodToTs({ zod: option, ...props })
+      );
+      return `[${types.join(", ")}]`;
+    }
+    case "ZodRecord": {
+      const valueType = zodToTs({
+        zod: zod._def.valueType,
+        ...props
+      });
+      return `{ [x: string]: ${valueType} }`;
+    }
+    case "ZodMap": {
+      const valueType = zodToTs({
+        zod: zod._def.valueType,
+        ...props
+      });
+      const keyType = zodToTs({
+        zod: zod._def.keyType,
+        ...props
+      });
+      return `Map<${keyType}, ${valueType}>`;
+    }
+    case "ZodSet": {
+      const type = zodToTs({
+        zod: zod._def.valueType,
+        ...props
+      });
+      return `Set<${type}>`;
+    }
+    case "ZodIntersection": {
+      const left = zodToTs({
+        zod: zod._def.left,
+        ...props
+      });
+      const right = zodToTs({
+        zod: zod._def.right,
+        ...props
+      });
+      return `${left} & ${right}`;
+    }
+    case "ZodPromise": {
+      const type = zodToTs({
+        zod: zod._def.type,
+        ...props
+      });
+      return `Promise<${type}>`;
+    }
+    case "ZodFunction": {
+      const argTypes = zod._def.args._def.items.map(
+        (arg, index) => {
+          const argType = zodToTs({
+            zod: arg,
+            ...props
+          });
+          return `args_${index}: ${argType}`;
+        }
+      );
+      argTypes.push("...args: any[]");
+      const returnType = zodToTs({
+        zod: zod._def.returns,
+        ...props
+      });
+      return `(${argTypes.join(", ")}) => ${returnType}`;
+    }
+    case "ZodDefault": {
+      const type = zodToTs({
+        zod: zod._def.innerType,
+        ...props
+      });
+      return type;
+    }
+  }
+  return "any";
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  zodToTs
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umijs/zod2ts",
-  "version": "4.0.59",
+  "version": "4.0.61",
   "description": "@umijs/zod2ts",
   "homepage": "https://github.com/umijs/umi/tree/master/packages/zod2ts#readme",
   "bugs": "https://github.com/umijs/umi/issues",
@@ -14,12 +14,6 @@
   "files": [
     "dist"
   ],
-  "dependencies": {
-    "@umijs/utils": "4.0.59"
-  },
-  "peerDependencies": {
-    "typescript": "^4"
-  },
   "publishConfig": {
     "access": "public"
   },
@@ -29,6 +23,7 @@
   "scripts": {
     "build": "umi-scripts father build",
     "build:deps": "umi-scripts bundleDeps",
-    "dev": "umi-scripts father dev"
+    "dev": "umi-scripts father dev",
+    "test": "umi-scripts jest-turbo"
   }
 }