@umijs/utils 4.0.0-canary.20230227.1 → 4.0.0-canary.20230309.3

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

@@ -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

@@ -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

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

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

@@ -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

@@ -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

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