npm - @umijs/utils - Versions diffs - 4.0.55 → 4.0.57 - Mend

@umijs/utils 4.0.55 → 4.0.57

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (42) hide show

package/compiled/zod/LICENSE +21 -0
package/compiled/zod/index.d.ts +2 -0
package/compiled/zod/index.js +1 -0
package/compiled/zod/lib/ZodError.d.ts +159 -0
package/compiled/zod/lib/__tests__/Mocker.d.ts +17 -0
package/compiled/zod/lib/benchmarks/discriminatedUnion.d.ts +5 -0
package/compiled/zod/lib/benchmarks/index.d.ts +1 -0
package/compiled/zod/lib/benchmarks/object.d.ts +5 -0
package/compiled/zod/lib/benchmarks/primitives.d.ts +5 -0
package/compiled/zod/lib/benchmarks/realworld.d.ts +5 -0
package/compiled/zod/lib/benchmarks/string.d.ts +5 -0
package/compiled/zod/lib/benchmarks/union.d.ts +5 -0
package/compiled/zod/lib/errors.d.ts +5 -0
package/compiled/zod/lib/external.d.ts +6 -0
package/compiled/zod/lib/helpers/enumUtil.d.ts +8 -0
package/compiled/zod/lib/helpers/errorUtil.d.ts +9 -0
package/compiled/zod/lib/helpers/parseUtil.d.ts +78 -0
package/compiled/zod/lib/helpers/partialUtil.d.ts +8 -0
package/compiled/zod/lib/helpers/typeAliases.d.ts +2 -0
package/compiled/zod/lib/helpers/util.d.ts +47 -0
package/compiled/zod/lib/index.d.ts +4 -0
package/compiled/zod/lib/locales/en.d.ts +3 -0
package/compiled/zod/lib/types.d.ts +975 -0
package/compiled/zod/package.json +1 -0
package/dist/BaseGenerator/BaseGenerator.js +4 -0
package/dist/BaseGenerator/generateFile.js +1 -4
package/dist/Generator/Generator.js +4 -0
package/dist/getDevBanner.js +11 -22
package/dist/getGitInfo.js +1 -4
package/dist/importLazy.js +2 -7
package/dist/index.d.ts +4 -1
package/dist/index.js +7 -2
package/dist/installDeps.js +10 -16
package/dist/npmClient.js +4 -0
package/dist/printHelp.js +2 -7
package/dist/randomColor/randomColor.js +1 -4
package/dist/register.js +2 -0
package/dist/zod/isZodSchema.d.ts +2 -0
package/dist/zod/isZodSchema.js +31 -0
package/dist/zod/zod2string.d.ts +2 -0
package/dist/zod/zod2string.js +49 -0
package/package.json +5 -3

package/compiled/zod/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2020 Colin McDonnell
+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/compiled/zod/index.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export * from "./lib";
2	+ export as namespace Zod;

package/compiled/zod/index.js ADDED Viewed

@@ -0,0 +1 @@

package/compiled/zod/lib/ZodError.d.ts ADDED Viewed

@@ -0,0 +1,159 @@
+import type { TypeOf, ZodType } from ".";
+import { Primitive } from "./helpers/typeAliases";
+import { util, ZodParsedType } from "./helpers/util";
+declare type allKeys<T> = T extends any ? keyof T : never;
+export declare type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
+export declare type typeToFlattenedError<T, U = string> = {
+    formErrors: U[];
+    fieldErrors: {
+        [P in allKeys<T>]?: U[];
+    };
+};
+export declare const ZodIssueCode: {
+    invalid_type: "invalid_type";
+    invalid_literal: "invalid_literal";
+    custom: "custom";
+    invalid_union: "invalid_union";
+    invalid_union_discriminator: "invalid_union_discriminator";
+    invalid_enum_value: "invalid_enum_value";
+    unrecognized_keys: "unrecognized_keys";
+    invalid_arguments: "invalid_arguments";
+    invalid_return_type: "invalid_return_type";
+    invalid_date: "invalid_date";
+    invalid_string: "invalid_string";
+    too_small: "too_small";
+    too_big: "too_big";
+    invalid_intersection_types: "invalid_intersection_types";
+    not_multiple_of: "not_multiple_of";
+    not_finite: "not_finite";
+};
+export declare type ZodIssueCode = keyof typeof ZodIssueCode;
+export declare type ZodIssueBase = {
+    path: (string | number)[];
+    message?: string;
+};
+export interface ZodInvalidTypeIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_type;
+    expected: ZodParsedType;
+    received: ZodParsedType;
+}
+export interface ZodInvalidLiteralIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_literal;
+    expected: unknown;
+    received: unknown;
+}
+export interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.unrecognized_keys;
+    keys: string[];
+}
+export interface ZodInvalidUnionIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union;
+    unionErrors: ZodError[];
+}
+export interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union_discriminator;
+    options: Primitive[];
+}
+export interface ZodInvalidEnumValueIssue extends ZodIssueBase {
+    received: string | number;
+    code: typeof ZodIssueCode.invalid_enum_value;
+    options: (string | number)[];
+}
+export interface ZodInvalidArgumentsIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_arguments;
+    argumentsError: ZodError;
+}
+export interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_return_type;
+    returnTypeError: ZodError;
+}
+export interface ZodInvalidDateIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_date;
+}
+export declare type StringValidation = "email" | "url" | "uuid" | "regex" | "cuid" | "cuid2" | "datetime" | {
+    startsWith: string;
+} | {
+    endsWith: string;
+};
+export interface ZodInvalidStringIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_string;
+    validation: StringValidation;
+}
+export interface ZodTooSmallIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.too_small;
+    minimum: number;
+    inclusive: boolean;
+    exact?: boolean;
+    type: "array" | "string" | "number" | "set" | "date";
+}
+export interface ZodTooBigIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.too_big;
+    maximum: number;
+    inclusive: boolean;
+    exact?: boolean;
+    type: "array" | "string" | "number" | "set" | "date";
+}
+export interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_intersection_types;
+}
+export interface ZodNotMultipleOfIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.not_multiple_of;
+    multipleOf: number;
+}
+export interface ZodNotFiniteIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.not_finite;
+}
+export interface ZodCustomIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.custom;
+    params?: {
+        [k: string]: any;
+    };
+}
+export declare type DenormalizedError = {
+    [k: string]: DenormalizedError | string[];
+};
+export declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
+export declare type ZodIssue = ZodIssueOptionalMessage & {
+    fatal?: boolean;
+    message: string;
+};
+export declare const quotelessJson: (obj: any) => string;
+export declare type ZodFormattedError<T, U = string> = {
+    _errors: U[];
+} & (NonNullable<T> extends [any, ...any[]] ? {
+    [K in keyof NonNullable<T>]?: ZodFormattedError<NonNullable<T>[K], U>;
+} : NonNullable<T> extends any[] ? {
+    [k: number]: ZodFormattedError<NonNullable<T>[number], U>;
+} : NonNullable<T> extends object ? {
+    [K in keyof NonNullable<T>]?: ZodFormattedError<NonNullable<T>[K], U>;
+} : unknown);
+export declare type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
+export declare class ZodError<T = any> extends Error {
+    issues: ZodIssue[];
+    get errors(): ZodIssue[];
+    constructor(issues: ZodIssue[]);
+    format(): ZodFormattedError<T>;
+    format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
+    static create: (issues: ZodIssue[]) => ZodError<any>;
+    toString(): string;
+    get message(): string;
+    get isEmpty(): boolean;
+    addIssue: (sub: ZodIssue) => void;
+    addIssues: (subs?: ZodIssue[]) => void;
+    flatten(): typeToFlattenedError<T>;
+    flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
+    get formErrors(): typeToFlattenedError<T, string>;
+}
+declare type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
+export declare type IssueData = stripPath<ZodIssueOptionalMessage> & {
+    path?: (string | number)[];
+    fatal?: boolean;
+};
+export declare type ErrorMapCtx = {
+    defaultError: string;
+    data: any;
+};
+export declare type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+    message: string;
+};
+export {};

package/compiled/zod/lib/__tests__/Mocker.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+export declare class Mocker {
+    pick: (...args: any[]) => any;
+    get string(): string;
+    get number(): number;
+    get bigint(): bigint;
+    get boolean(): boolean;
+    get date(): Date;
+    get symbol(): symbol;
+    get null(): null;
+    get undefined(): undefined;
+    get stringOptional(): any;
+    get stringNullable(): any;
+    get numberOptional(): any;
+    get numberNullable(): any;
+    get booleanOptional(): any;
+    get booleanNullable(): any;
+}

package/compiled/zod/lib/benchmarks/discriminatedUnion.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

package/compiled/zod/lib/benchmarks/index.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/compiled/zod/lib/benchmarks/object.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

package/compiled/zod/lib/benchmarks/primitives.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

package/compiled/zod/lib/benchmarks/realworld.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

package/compiled/zod/lib/benchmarks/string.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

package/compiled/zod/lib/benchmarks/union.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

package/compiled/zod/lib/errors.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import defaultErrorMap from "./locales/en";
+import type { ZodErrorMap } from "./ZodError";
+export { defaultErrorMap };
+export declare function setErrorMap(map: ZodErrorMap): void;
+export declare function getErrorMap(): ZodErrorMap;

package/compiled/zod/lib/external.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+export * from "./errors";
+export * from "./helpers/parseUtil";
+export * from "./helpers/typeAliases";
+export * from "./helpers/util";
+export * from "./types";
+export * from "./ZodError";

package/compiled/zod/lib/helpers/enumUtil.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+export declare namespace enumUtil {
+    type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends (k: infer Intersection) => void ? Intersection : never;
+    type GetUnionLast<T> = UnionToIntersectionFn<T> extends () => infer Last ? Last : never;
+    type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never] ? Tuple : UnionToTuple<Exclude<T, GetUnionLast<T>>, [GetUnionLast<T>, ...Tuple]>;
+    type CastToStringTuple<T> = T extends [string, ...string[]] ? T : never;
+    export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;
+    export {};
+}

package/compiled/zod/lib/helpers/errorUtil.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+export declare namespace errorUtil {
+    type ErrMessage = string | {
+        message?: string;
+    };
+    const errToObj: (message?: ErrMessage | undefined) => {
+        message?: string | undefined;
+    };
+    const toString: (message?: ErrMessage | undefined) => string | undefined;
+}

package/compiled/zod/lib/helpers/parseUtil.d.ts ADDED Viewed

@@ -0,0 +1,78 @@
+import type { IssueData, ZodErrorMap, ZodIssue } from "../ZodError";
+import type { ZodParsedType } from "./util";
+export declare const makeIssue: (params: {
+    data: any;
+    path: (string | number)[];
+    errorMaps: ZodErrorMap[];
+    issueData: IssueData;
+}) => ZodIssue;
+export declare type ParseParams = {
+    path: (string | number)[];
+    errorMap: ZodErrorMap;
+    async: boolean;
+};
+export declare type ParsePathComponent = string | number;
+export declare type ParsePath = ParsePathComponent[];
+export declare const EMPTY_PATH: ParsePath;
+export interface ParseContext {
+    readonly common: {
+        readonly issues: ZodIssue[];
+        readonly contextualErrorMap?: ZodErrorMap;
+        readonly async: boolean;
+    };
+    readonly path: ParsePath;
+    readonly schemaErrorMap?: ZodErrorMap;
+    readonly parent: ParseContext | null;
+    readonly data: any;
+    readonly parsedType: ZodParsedType;
+}
+export declare type ParseInput = {
+    data: any;
+    path: (string | number)[];
+    parent: ParseContext;
+};
+export declare function addIssueToContext(ctx: ParseContext, issueData: IssueData): void;
+export declare type ObjectPair = {
+    key: SyncParseReturnType<any>;
+    value: SyncParseReturnType<any>;
+};
+export declare class ParseStatus {
+    value: "aborted" | "dirty" | "valid";
+    dirty(): void;
+    abort(): void;
+    static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
+    static mergeObjectAsync(status: ParseStatus, pairs: {
+        key: ParseReturnType<any>;
+        value: ParseReturnType<any>;
+    }[]): Promise<SyncParseReturnType<any>>;
+    static mergeObjectSync(status: ParseStatus, pairs: {
+        key: SyncParseReturnType<any>;
+        value: SyncParseReturnType<any>;
+        alwaysSet?: boolean;
+    }[]): SyncParseReturnType;
+}
+export interface ParseResult {
+    status: "aborted" | "dirty" | "valid";
+    data: any;
+}
+export declare type INVALID = {
+    status: "aborted";
+};
+export declare const INVALID: INVALID;
+export declare type DIRTY<T> = {
+    status: "dirty";
+    value: T;
+};
+export declare const DIRTY: <T>(value: T) => DIRTY<T>;
+export declare type OK<T> = {
+    status: "valid";
+    value: T;
+};
+export declare const OK: <T>(value: T) => OK<T>;
+export declare type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
+export declare type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
+export declare type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
+export declare const isAborted: (x: ParseReturnType<any>) => x is INVALID;
+export declare const isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
+export declare const isValid: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
+export declare const isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;

package/compiled/zod/lib/helpers/partialUtil.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import type { ZodArray, ZodNullable, ZodObject, ZodOptional, ZodTuple, ZodTupleItems, ZodTypeAny } from "../index";
+export declare namespace partialUtil {
+    type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<infer Shape, infer Params, infer Catchall> ? ZodObject<{
+        [k in keyof Shape]: ZodOptional<DeepPartial<Shape[k]>>;
+    }, Params, Catchall> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? {
+        [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never;
+    } extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
+}

package/compiled/zod/lib/helpers/typeAliases.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export declare type Primitive = string \| number \| symbol \| bigint \| boolean \| null \| undefined;
2	+ export declare type Scalars = Primitive \| Primitive[];

package/compiled/zod/lib/helpers/util.d.ts ADDED Viewed

@@ -0,0 +1,47 @@
+export declare namespace util {
+    type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
+    export const assertEqual: <A, B>(val: AssertEqual<A, B>) => AssertEqual<A, B>;
+    export function assertIs<T>(_arg: T): void;
+    export function assertNever(_x: never): never;
+    export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
+    export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
+    export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+    export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
+    export const getValidEnumValues: (obj: any) => any[];
+    export const objectValues: (obj: any) => any[];
+    export const objectKeys: ObjectConstructor["keys"];
+    export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
+    export type identity<T> = T;
+    export type flatten<T> = identity<{
+        [k in keyof T]: T[k];
+    }>;
+    export type noUndefined<T> = T extends undefined ? never : T;
+    export const isInteger: NumberConstructor["isInteger"];
+    export function joinValues<T extends any[]>(array: T, separator?: string): string;
+    export const jsonStringifyReplacer: (_: string, value: any) => any;
+    export {};
+}
+export declare const ZodParsedType: {
+    function: "function";
+    number: "number";
+    string: "string";
+    nan: "nan";
+    integer: "integer";
+    float: "float";
+    boolean: "boolean";
+    date: "date";
+    bigint: "bigint";
+    symbol: "symbol";
+    undefined: "undefined";
+    null: "null";
+    array: "array";
+    object: "object";
+    unknown: "unknown";
+    promise: "promise";
+    void: "void";
+    never: "never";
+    map: "map";
+    set: "set";
+};
+export declare type ZodParsedType = keyof typeof ZodParsedType;
+export declare const getParsedType: (data: any) => ZodParsedType;

package/compiled/zod/lib/index.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+import * as mod from "./external";
+export * from "./external";
+export { mod as z };
+export default mod;

package/compiled/zod/lib/locales/en.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { ZodErrorMap } from "../ZodError";
+declare const errorMap: ZodErrorMap;
+export default errorMap;