@umijs/zod2ts 4.0.0-canary.20230314.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-present ChenCheng (sorrycc@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

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,8 @@
+import type { ZodTypeAny } from '@umijs/utils/compiled/zod';
+import { GetType, RequiredZodToTsOptions, ZodToTsOptions, ZodToTsReturn } from './types';
+import { createTypeAlias, printNode } from './utils';
+export declare const resolveOptions: (raw?: ZodToTsOptions) => RequiredZodToTsOptions;
+export declare const zodToTs: (zod: ZodTypeAny, identifier?: string, options?: ZodToTsOptions) => ZodToTsReturn;
+export { withGetType } from './utils';
+export { createTypeAlias, printNode };
+export type { GetType, ZodToTsOptions };

package/dist/index.js

@@ -0,0 +1,312 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createTypeAlias: () => import_utils.createTypeAlias,
+  printNode: () => import_utils.printNode,
+  resolveOptions: () => resolveOptions,
+  withGetType: () => import_utils2.withGetType,
+  zodToTs: () => zodToTs
+});
+module.exports = __toCommonJS(src_exports);
+var import_typescript = __toESM(require("typescript"));
+var import_utils = require("./utils");
+var import_utils2 = require("./utils");
+var { factory: f } = import_typescript.default;
+var callGetType = (zod, identifier, options) => {
+  let type = null;
+  if (zod.getType)
+    type = zod.getType(import_typescript.default, identifier, options);
+  return type;
+};
+var resolveOptions = (raw) => {
+  const resolved = { resolveNativeEnums: true };
+  return { ...resolved, ...raw };
+};
+var zodToTs = (zod, identifier, options) => {
+  const resolvedIdentifier = identifier ?? "Identifier";
+  const resolvedOptions = resolveOptions(options);
+  const store = { nativeEnums: [] };
+  const node = zodToTsNode(zod, resolvedIdentifier, store, resolvedOptions);
+  return { node, store };
+};
+var zodToTsNode = (zod, identifier, store, options) => {
+  const { typeName } = zod._def;
+  const getTypeType = callGetType(zod, identifier, options);
+  if (getTypeType && typeName !== "ZodNativeEnum") {
+    return (0, import_utils.maybeIdentifierToTypeReference)(getTypeType);
+  }
+  const otherArgs = [identifier, store, options];
+  switch (typeName) {
+    case "ZodString":
+      return f.createKeywordTypeNode(import_typescript.default.SyntaxKind.StringKeyword);
+    case "ZodNumber":
+      return f.createKeywordTypeNode(import_typescript.default.SyntaxKind.NumberKeyword);
+    case "ZodBigInt":
+      return f.createKeywordTypeNode(import_typescript.default.SyntaxKind.BigIntKeyword);
+    case "ZodBoolean":
+      return f.createKeywordTypeNode(import_typescript.default.SyntaxKind.BooleanKeyword);
+    case "ZodDate":
+      return f.createTypeReferenceNode(f.createIdentifier("Date"));
+    case "ZodUndefined":
+      return f.createKeywordTypeNode(import_typescript.default.SyntaxKind.UndefinedKeyword);
+    case "ZodNull":
+      return f.createLiteralTypeNode(f.createNull());
+    case "ZodVoid":
+      return f.createUnionTypeNode([
+        f.createKeywordTypeNode(import_typescript.default.SyntaxKind.VoidKeyword),
+        f.createKeywordTypeNode(import_typescript.default.SyntaxKind.UndefinedKeyword)
+      ]);
+    case "ZodAny":
+      return f.createKeywordTypeNode(import_typescript.default.SyntaxKind.AnyKeyword);
+    case "ZodUnknown":
+      return (0, import_utils.createUnknownKeywordNode)();
+    case "ZodNever":
+      return f.createKeywordTypeNode(import_typescript.default.SyntaxKind.NeverKeyword);
+    case "ZodLazy": {
+      if (!getTypeType)
+        return (0, import_utils.createTypeReferenceFromString)(identifier);
+      break;
+    }
+    case "ZodLiteral": {
+      let literal;
+      const literalValue = zod._def.value;
+      switch (typeof literalValue) {
+        case "number":
+          literal = f.createNumericLiteral(literalValue);
+          break;
+        case "boolean":
+          if (literalValue === true)
+            literal = f.createTrue();
+          else
+            literal = f.createFalse();
+          break;
+        default:
+          literal = f.createStringLiteral(literalValue);
+          break;
+      }
+      return f.createLiteralTypeNode(literal);
+    }
+    case "ZodObject": {
+      const properties = Object.entries(zod._def.shape());
+      const members = properties.map(([key, value]) => {
+        const nextZodNode = value;
+        const type = zodToTsNode(nextZodNode, ...otherArgs);
+        const { typeName: nextZodNodeTypeName } = nextZodNode._def;
+        const isOptional = nextZodNodeTypeName === "ZodOptional" || nextZodNode.isOptional();
+        const propertySignature = f.createPropertySignature(
+          void 0,
+          (0, import_utils.getIdentifierOrStringLiteral)(key),
+          isOptional ? f.createToken(import_typescript.default.SyntaxKind.QuestionToken) : void 0,
+          type
+        );
+        if (nextZodNode.description) {
+          (0, import_utils.addJsDocComment)(propertySignature, nextZodNode.description);
+        }
+        return propertySignature;
+      });
+      return f.createTypeLiteralNode(members);
+    }
+    case "ZodArray": {
+      const type = zodToTsNode(zod._def.type, ...otherArgs);
+      const node = f.createArrayTypeNode(type);
+      return node;
+    }
+    case "ZodEnum": {
+      const types = zod._def.values.map(
+        (value) => f.createStringLiteral(value)
+      );
+      return f.createUnionTypeNode(types);
+    }
+    case "ZodUnion": {
+      const options2 = zod._def.options;
+      const types = options2.map(
+        (option) => zodToTsNode(option, ...otherArgs)
+      );
+      return f.createUnionTypeNode(types);
+    }
+    case "ZodDiscriminatedUnion": {
+      const options2 = [...zod._def.options.values()];
+      const types = options2.map(
+        (option) => zodToTsNode(option, ...otherArgs)
+      );
+      return f.createUnionTypeNode(types);
+    }
+    case "ZodEffects": {
+      const node = zodToTsNode(zod._def.schema, ...otherArgs);
+      return node;
+    }
+    case "ZodNativeEnum": {
+      let type = getTypeType;
+      if (!type)
+        return (0, import_utils.createUnknownKeywordNode)();
+      if (options.resolveNativeEnums) {
+        const enumMembers = Object.entries(
+          zod._def.values
+        ).map(([key, value]) => {
+          const literal = typeof value === "number" ? f.createNumericLiteral(value) : f.createStringLiteral(value);
+          return f.createEnumMember((0, import_utils.getIdentifierOrStringLiteral)(key), literal);
+        });
+        if (import_typescript.default.isIdentifier(type)) {
+          store.nativeEnums.push(
+            f.createEnumDeclaration(void 0, type, enumMembers)
+          );
+        } else {
+          throw new Error(
+            "getType on nativeEnum must return an identifier when resolveNativeEnums is set"
+          );
+        }
+      }
+      type = (0, import_utils.maybeIdentifierToTypeReference)(type);
+      return type;
+    }
+    case "ZodOptional": {
+      const innerType = zodToTsNode(
+        zod._def.innerType,
+        ...otherArgs
+      );
+      return f.createUnionTypeNode([
+        innerType,
+        f.createKeywordTypeNode(import_typescript.default.SyntaxKind.UndefinedKeyword)
+      ]);
+    }
+    case "ZodNullable": {
+      const innerType = zodToTsNode(
+        zod._def.innerType,
+        ...otherArgs
+      );
+      return f.createUnionTypeNode([
+        innerType,
+        f.createLiteralTypeNode(f.createNull())
+      ]);
+    }
+    case "ZodTuple": {
+      const types = zod._def.items.map(
+        (option) => zodToTsNode(option, ...otherArgs)
+      );
+      return f.createTupleTypeNode(types);
+    }
+    case "ZodRecord": {
+      const valueType = zodToTsNode(zod._def.valueType, ...otherArgs);
+      const node = f.createTypeLiteralNode([
+        f.createIndexSignature(
+          void 0,
+          [
+            f.createParameterDeclaration(
+              void 0,
+              void 0,
+              f.createIdentifier("x"),
+              void 0,
+              f.createKeywordTypeNode(import_typescript.default.SyntaxKind.StringKeyword),
+              void 0
+            )
+          ],
+          valueType
+        )
+      ]);
+      return node;
+    }
+    case "ZodMap": {
+      const valueType = zodToTsNode(zod._def.valueType, ...otherArgs);
+      const keyType = zodToTsNode(zod._def.keyType, ...otherArgs);
+      const node = f.createTypeReferenceNode(f.createIdentifier("Map"), [
+        keyType,
+        valueType
+      ]);
+      return node;
+    }
+    case "ZodSet": {
+      const type = zodToTsNode(zod._def.valueType, ...otherArgs);
+      const node = f.createTypeReferenceNode(f.createIdentifier("Set"), [type]);
+      return node;
+    }
+    case "ZodIntersection": {
+      const left = zodToTsNode(zod._def.left, ...otherArgs);
+      const right = zodToTsNode(zod._def.right, ...otherArgs);
+      const node = f.createIntersectionTypeNode([left, right]);
+      return node;
+    }
+    case "ZodPromise": {
+      const type = zodToTsNode(zod._def.type, ...otherArgs);
+      const node = f.createTypeReferenceNode(f.createIdentifier("Promise"), [
+        type
+      ]);
+      return node;
+    }
+    case "ZodFunction": {
+      const argTypes = zod._def.args._def.items.map(
+        (arg, index) => {
+          const argType = zodToTsNode(arg, ...otherArgs);
+          return f.createParameterDeclaration(
+            void 0,
+            void 0,
+            f.createIdentifier(`args_${index}`),
+            void 0,
+            argType,
+            void 0
+          );
+        }
+      );
+      argTypes.push(
+        f.createParameterDeclaration(
+          void 0,
+          f.createToken(import_typescript.default.SyntaxKind.DotDotDotToken),
+          f.createIdentifier(`args_${argTypes.length}`),
+          void 0,
+          f.createArrayTypeNode((0, import_utils.createUnknownKeywordNode)()),
+          void 0
+        )
+      );
+      const returnType = zodToTsNode(zod._def.returns, ...otherArgs);
+      const node = f.createFunctionTypeNode(void 0, argTypes, returnType);
+      return node;
+    }
+    case "ZodDefault": {
+      const type = zodToTsNode(zod._def.innerType, ...otherArgs);
+      const filteredNodes = [];
+      type.forEachChild((node) => {
+        if (![import_typescript.default.SyntaxKind.UndefinedKeyword].includes(node.kind)) {
+          filteredNodes.push(node);
+        }
+      });
+      type.types = filteredNodes;
+      return type;
+    }
+  }
+  return f.createKeywordTypeNode(import_typescript.default.SyntaxKind.AnyKeyword);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTypeAlias,
+  printNode,
+  resolveOptions,
+  withGetType,
+  zodToTs
+});

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+import ts from 'typescript';
+export declare type LiteralType = string | number | boolean;
+export declare type ZodToTsOptions = {
+    resolveNativeEnums?: boolean;
+};
+export declare type RequiredZodToTsOptions = Required<ZodToTsOptions>;
+export declare type ZodToTsStore = {
+    nativeEnums: ts.EnumDeclaration[];
+};
+export declare type ZodToTsReturn = {
+    node: ts.TypeNode;
+    store: ZodToTsStore;
+};
+export declare type GetTypeFunction = (typescript: typeof ts, identifier: string, options: RequiredZodToTsOptions) => ts.Identifier | ts.TypeNode;
+export declare type GetType = {
+    getType?: GetTypeFunction;
+};

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/utils.d.ts

@@ -0,0 +1,11 @@
+import type { ZodTypeAny } from '@umijs/utils/compiled/zod';
+import ts from 'typescript';
+import type { GetType, GetTypeFunction } from './types';
+export declare const maybeIdentifierToTypeReference: (identifier: ts.Identifier | ts.TypeNode) => ts.TypeNode;
+export declare const createTypeReferenceFromString: (identifier: string) => ts.TypeReferenceNode;
+export declare const createUnknownKeywordNode: () => ts.KeywordTypeNode<ts.SyntaxKind.UnknownKeyword>;
+export declare const createTypeAlias: (node: ts.TypeNode, identifier: string, comment?: string) => ts.TypeAliasDeclaration;
+export declare const printNode: (node: ts.Node, printerOptions?: ts.PrinterOptions) => string;
+export declare const withGetType: <T extends ZodTypeAny & GetType>(schema: T, getType: GetTypeFunction) => T;
+export declare const getIdentifierOrStringLiteral: (str: string) => ts.Identifier | ts.StringLiteral;
+export declare const addJsDocComment: (node: ts.Node, text: string) => void;

package/dist/utils.js

@@ -0,0 +1,104 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  addJsDocComment: () => addJsDocComment,
+  createTypeAlias: () => createTypeAlias,
+  createTypeReferenceFromString: () => createTypeReferenceFromString,
+  createUnknownKeywordNode: () => createUnknownKeywordNode,
+  getIdentifierOrStringLiteral: () => getIdentifierOrStringLiteral,
+  maybeIdentifierToTypeReference: () => maybeIdentifierToTypeReference,
+  printNode: () => printNode,
+  withGetType: () => withGetType
+});
+module.exports = __toCommonJS(utils_exports);
+var import_typescript = __toESM(require("typescript"));
+var { factory: f } = import_typescript.default;
+var maybeIdentifierToTypeReference = (identifier) => {
+  if (import_typescript.default.isIdentifier(identifier)) {
+    return f.createTypeReferenceNode(identifier);
+  }
+  return identifier;
+};
+var createTypeReferenceFromString = (identifier) => f.createTypeReferenceNode(f.createIdentifier(identifier));
+var createUnknownKeywordNode = () => f.createKeywordTypeNode(import_typescript.default.SyntaxKind.UnknownKeyword);
+var createTypeAlias = (node, identifier, comment) => {
+  const typeAlias = f.createTypeAliasDeclaration(
+    void 0,
+    f.createIdentifier(identifier),
+    void 0,
+    node
+  );
+  if (comment) {
+    addJsDocComment(typeAlias, comment);
+  }
+  return typeAlias;
+};
+var printNode = (node, printerOptions) => {
+  const sourceFile = import_typescript.default.createSourceFile(
+    "print.ts",
+    "",
+    import_typescript.default.ScriptTarget.Latest,
+    false,
+    import_typescript.default.ScriptKind.TS
+  );
+  const printer = import_typescript.default.createPrinter(printerOptions);
+  return printer.printNode(import_typescript.default.EmitHint.Unspecified, node, sourceFile);
+};
+var withGetType = (schema, getType) => {
+  schema.getType = getType;
+  return schema;
+};
+var identifierRE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var getIdentifierOrStringLiteral = (str) => {
+  if (identifierRE.test(str)) {
+    return f.createIdentifier(str);
+  }
+  return f.createStringLiteral(str);
+};
+var addJsDocComment = (node, text) => {
+  import_typescript.default.addSyntheticLeadingComment(
+    node,
+    import_typescript.default.SyntaxKind.MultiLineCommentTrivia,
+    `* ${text} `,
+    true
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addJsDocComment,
+  createTypeAlias,
+  createTypeReferenceFromString,
+  createUnknownKeywordNode,
+  getIdentifierOrStringLiteral,
+  maybeIdentifierToTypeReference,
+  printNode,
+  withGetType
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@umijs/zod2ts",
+  "version": "4.0.0-canary.20230314.1",
+  "description": "@umijs/zod2ts",
+  "homepage": "https://github.com/umijs/umi/tree/master/packages/zod2ts#readme",
+  "bugs": "https://github.com/umijs/umi/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/umijs/umi"
+  },
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@umijs/utils": "4.0.0-canary.20230314.1"
+  },
+  "peerDependencies": {
+    "typescript": "^4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "authors": [
+    "chencheng <sorrycc@gmail.com> (https://github.com/sorrycc)"
+  ],
+  "scripts": {
+    "build": "umi-scripts father build",
+    "build:deps": "umi-scripts bundleDeps",
+    "dev": "umi-scripts father dev",
+    "test": "umi-scripts jest-turbo"
+  }
+}