@umijs/zod2ts 4.0.0-canary.20230315.1 → 4.0.58

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umijs/zod2ts",
-  "version": "4.0.0-canary.20230315.1",
+  "version": "4.0.58",
   "description": "@umijs/zod2ts",
   "homepage": "https://github.com/umijs/umi/tree/master/packages/zod2ts#readme",
   "bugs": "https://github.com/umijs/umi/issues",
@@ -15,7 +15,7 @@
     "dist"
   ],
   "dependencies": {
-    "@umijs/utils": "4.0.0-canary.20230315.1"
+    "@umijs/utils": "4.0.58"
   },
   "peerDependencies": {
     "typescript": "^4"
@@ -29,7 +29,6 @@
   "scripts": {
     "build": "umi-scripts father build",
     "build:deps": "umi-scripts bundleDeps",
-    "dev": "umi-scripts father dev",
-    "test": "umi-scripts jest-turbo"
+    "dev": "umi-scripts father dev"
   }
 }

package/README.md

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

package/dist/index.d.ts

@@ -1,8 +0,0 @@
-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

@@ -1,312 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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
-});