common-resolver - npm Package Compare versions

Comparing version 0.0.13 to 0.0.14

dist/exports/superstruct.d.ts

+export * from '../superstruct/isSuperstructSchema';
+export * from '../superstruct/superstructParser';
+export * from '../superstruct/superstructResolver';

dist/exports/superstruct.js

+export * from '../superstruct/isSuperstructSchema';
+export * from '../superstruct/superstructParser';
+export * from '../superstruct/superstructResolver';

dist/exports/utils.d.ts

+export * from '../utils/getResolver';

dist/exports/utils.js

+export * from '../utils/getResolver';

dist/exports/yup.d.ts

+export * from '../yup/isYupSchema';
+export * from '../yup/yupParser';
+export * from '../yup/yupResolver';

dist/exports/yup.js

+export * from '../yup/isYupSchema';
+export * from '../yup/yupParser';
+export * from '../yup/yupResolver';

dist/exports/zod.d.ts

+export * from '../zod/isZodSchema';
+export * from '../zod/zodParser';
+export * from '../zod/zodResolver';

dist/exports/zod.js

+export * from '../zod/isZodSchema';
+export * from '../zod/zodParser';
+export * from '../zod/zodResolver';

dist/ss/isSuperstructSchema.d.ts

+export declare function isSuperstructSchema<T>(validator: any): validator is import("superstruct").Struct<T, any>;

dist/ss/isSuperstructSchema.js

+export function isSuperstructSchema(validator) {
+    return validator instanceof (require("superstruct").Struct);
+}

dist/ss/ssParser.d.ts

+export declare function superstructParser<T>(data: T, schema: import("superstruct").Struct<T, any>, options?: {
+    throwError: boolean;
+}): T;

dist/ss/ssParser.js

+import { commonParser } from "../utils/commonParser";
+import { superstructResolver } from "./ssResolver";
+export function superstructParser(data, schema, options) {
+    return commonParser(data, schema, superstructResolver, options);
+}

dist/ss/ssResolver.d.ts

+import { Resolver } from "../types";
+export declare function superstructResolver<T>(schema: import("superstruct").Struct<T, any>): Resolver<T>;

dist/ss/ssResolver.js

+import { createErrorProxy, errorPathObjectify } from "../utils";
+export function superstructResolver(schema) {
+    const { validate } = require("superstruct");
+    const formatter = (obj) => {
+        return obj.reduce((acc, { message, path }) => {
+            acc[path.join('.') || "root"] = message;
+            return acc;
+        }, {});
+    };
+    return {
+        validate: (state) => {
+            const [error] = validate(state, schema);
+            if (!error) {
+                return {
+                    valid: true,
+                    error: null,
+                    data: state
+                };
+            }
+            else {
+                return {
+                    valid: false,
+                    error: createErrorProxy(errorPathObjectify(formatter(error.failures()))),
+                    data: null
+                };
+            }
+        }
+    };
+}

dist/superstruct.d.ts

+export * from './ss/isSuperstructSchema';
+export * from './ss/ssParser';
+export * from './ss/ssResolver';

dist/superstruct.js

+export * from './ss/isSuperstructSchema';
+export * from './ss/ssParser';
+export * from './ss/ssResolver';

dist/superstruct/isSuperstructSchema.d.ts

+export declare function isSuperstructSchema<T>(validator: any): validator is import("superstruct").Struct<T, any>;

dist/superstruct/isSuperstructSchema.js

+export function isSuperstructSchema(validator) {
+    return validator instanceof (require("superstruct").Struct);
+}

dist/superstruct/superstructParser.d.ts

+export declare function superstructParser<T>(data: T, schema: import("superstruct").Struct<T, any>, options?: {
+    throwError: boolean;
+}): T;

dist/superstruct/superstructParser.js

+import { commonParser } from "../utils/commonParser";
+import { superstructResolver } from "./superstructResolver";
+export function superstructParser(data, schema, options) {
+    return commonParser(data, schema, superstructResolver, options);
+}

dist/superstruct/superstructResolver.d.ts

+import { Resolver } from "../types";
+export declare function superstructResolver<T>(schema: import("superstruct").Struct<T, any>): Resolver<T>;

dist/superstruct/superstructResolver.js

+import { createErrorProxy, errorPathObjectify } from "../utils";
+export function superstructResolver(schema) {
+    const { validate } = require("superstruct");
+    const formatter = (obj) => {
+        return obj.reduce((acc, { message, path }) => {
+            acc[path.join('.') || "root"] = message;
+            return acc;
+        }, {});
+    };
+    return {
+        validate: (state) => {
+            const [error] = validate(state, schema);
+            if (!error) {
+                return {
+                    valid: true,
+                    error: null,
+                    data: state
+                };
+            }
+            else {
+                return {
+                    valid: false,
+                    error: createErrorProxy(errorPathObjectify(formatter(error.failures()))),
+                    data: null
+                };
+            }
+        }
+    };
+}

dist/util.d.ts

+export * from './utils/getResolver';

dist/util.js

+export * from './utils/getResolver';

dist/utils/commonParser.d.ts

+export declare function commonParser<T>(data: T, schema: any, resolver: any, options?: {
+    throwError: boolean;
+}): T;

dist/utils/commonParser.js

+export function commonParser(data, schema, resolver, options) {
+    const result = resolver(schema).validate(data);
+    if (!result.valid) {
+        if (options?.throwError) {
+            throw result.error;
+        }
+        else {
+            return data;
+        }
+    }
+    return data;
+}

dist/utils/getResolver.d.ts

+import { Resolver } from "../types";
+export type ValidateSchema<T> = {
+    zod: import("zod").ZodSchema<T>;
+    yup: import("yup").Schema<T>;
+    superstruct: import("superstruct").Struct<T, any>;
+};
+export declare function getResolver<T>(validator: ValidateSchema<T>[keyof ValidateSchema<T>]): Resolver<T>;

dist/utils/getResolver.js

+import { isSuperstructSchema } from "../superstruct/isSuperstructSchema";
+import { superstructResolver } from "../superstruct/superstructResolver";
+import { isYupSchema } from "../yup/isYupSchema";
+import { yupResolver } from "../yup/yupResolver";
+import { isZodSchema } from "../zod/isZodSchema";
+import { zodResolver } from "../zod/zodResolver";
+export function getResolver(validator) {
+    if (isZodSchema(validator)) {
+        return zodResolver(validator);
+    }
+    else if (isYupSchema(validator)) {
+        return yupResolver(validator);
+    }
+    else if (isSuperstructSchema(validator)) {
+        return superstructResolver(validator);
+    }
+    else {
+        throw new Error("Unsupported validation library");
+    }
+}

dist/yup.d.ts

+export * from './zod/isZodSchema';
+export * from './zod/zodParser';
+export * from './zod/zodResolver';

dist/yup.js

+export * from './zod/isZodSchema';
+export * from './zod/zodParser';
+export * from './zod/zodResolver';

dist/yup/isYupSchema.d.ts

+export declare function isYupSchema<T>(validator: any): validator is import("yup").Schema<T>;

dist/yup/isYupSchema.js

+export function isYupSchema(validator) {
+    return validator instanceof (require("yup").Schema);
+}

dist/yup/yupParser.d.ts

+export declare function yupParser<T>(data: T, schema: import("yup").Schema<T>, options?: {
+    throwError: boolean;
+}): T;

dist/yup/yupParser.js

+import { commonParser } from "../utils/commonParser";
+import { yupResolver } from "./yupResolver";
+export function yupParser(data, schema, options) {
+    return commonParser(data, schema, yupResolver, options);
+}

dist/yup/yupResolver.d.ts

+import { Resolver } from "../types";
+export declare function yupResolver<T>(schema: import("yup").Schema<T>): Resolver<T>;

dist/yup/yupResolver.js

+import { bracketIndexToDot, createErrorProxy, errorPathObjectify } from "../utils";
+export function yupResolver(schema) {
+    const formatter = (e) => {
+        return e.reduce((acc, err) => {
+            acc[bracketIndexToDot(err.path) || "root"] = err.errors[0];
+            return acc;
+        }, {});
+    };
+    return {
+        validate: (state) => {
+            try {
+                schema.validateSync(state, { abortEarly: false });
+                return {
+                    valid: true,
+                    error: null,
+                    data: state
+                };
+            }
+            catch (e) {
+                return {
+                    valid: false,
+                    error: createErrorProxy(errorPathObjectify(formatter(e.inner))),
+                    data: null
+                };
+            }
+        }
+    };
+}

dist/zod.d.ts

+export * from './zod/isZodSchema';
+export * from './zod/zodParser';
+export * from './zod/zodResolver';

dist/zod.js

+export * from './zod/isZodSchema';
+export * from './zod/zodParser';
+export * from './zod/zodResolver';

dist/zod/isZodSchema.d.ts

+export declare function isZodSchema<T>(validator: any): validator is import("zod").ZodSchema<T>;

dist/zod/isZodSchema.js

+export function isZodSchema(validator) {
+    return validator && typeof validator.parse === 'function' && typeof validator.safeParse === 'function';
+}

dist/zod/zodParser.d.ts

+export declare function zodParser<T>(data: T, schema: import("zod").ZodSchema<T>, options?: {
+    throwError: boolean;
+}): T;

dist/zod/zodParser.js

+import { commonParser } from "../utils/commonParser";
+import { zodResolver } from "./zodResolver";
+export function zodParser(data, schema, options) {
+    return commonParser(data, schema, zodResolver, options);
+}

dist/zod/zodResolver.d.ts

+import { Resolver } from "../types";
+export declare function zodResolver<T>(schema: import("zod").ZodSchema<T>): Resolver<T>;

dist/zod/zodResolver.js

+import { createErrorProxy, errorPathObjectify } from "../utils";
+export function zodResolver(schema) {
+    const formatter = (obj) => {
+        return obj.reduce((acc, { message, path }) => {
+            acc[path.join('.') || "root"] = message;
+            return acc;
+        }, {});
+    };
+    return {
+        validate: (state) => {
+            const result = schema.safeParse(state);
+            if (result.success) {
+                return {
+                    valid: true,
+                    error: null,
+                    data: state
+                };
+            }
+            else {
+                return {
+                    valid: false,
+                    error: createErrorProxy(errorPathObjectify(formatter(result.error.issues))),
+                    data: null
+                };
+            }
+        }
+    };
+}

dist/exports/types.d.ts

@@ -1,1 +0,1 @@
-export { ValidateSchema, Resolver } from "../type";
+export * from '../types';

dist/exports/types.js

@@ -1,1 +0,1 @@
-export {};
+export * from '../types';

dist/types.d.ts

@@ -1,22 +0,1 @@
-import { z } from "zod";
-import * as yup from "yup";
-import { Struct } from "superstruct";
-export type ValidateSchema<T> = {
-    zod: z.ZodSchema<T>;
-    yup: yup.Schema<T>;
-    superstruct: Struct<T, any>;
-};
-export type RecursivePartial<T> = {
-    [P in keyof T]?: T[P] extends object ? RecursivePartial<T[P]> : T[P];
-};
-export type Resolver<T> = {
-    validate: (state: T, name?: string) => {
-        valid: true;
-        error: null;
-    } | {
-        valid: false;
-        error: RecursivePartial<T> & {
-            "root"?: string;
-        };
-    };
-};
+export * from './types';

dist/types.js

@@ -1,1 +0,1 @@
-export {};
+export * from './types';

dist/types/index.d.ts

@@ -1,12 +0,7 @@
-import { z } from "zod";
-import * as yup from "yup";
-import { Struct } from "superstruct";
-export type ValidateSchema<T> = {
-    zod: z.ZodSchema<T>;
-    yup: yup.Schema<T>;
-    superstruct: Struct<T, any>;
-};
 export type RecursivePartial<T> = {
-    [P in keyof T]?: T[P] extends object ? RecursivePartial<T[P]> : T[P];
+    [P in keyof T]?: T[P] extends object ? RecursivePartial<T[P]> : string;
 };
+type CRES<T> = RecursivePartial<T> & {
+    "root"?: string;
+};
 export type Resolver<T> = {
@@ -16,11 +11,9 @@ validate: (state: T, name?: string) => {
         error: null;
+        data: T;
     } | {
         valid: false;
-        error: RecursivePartial<T> & {
-            "root"?: string;
-        };
+        error: CRES<T>;
+        data: null;
     };
 };
-export declare function isZodSchema<T>(validator: any): validator is import("zod").ZodSchema<T>;
-export declare function isYupSchema<T>(validator: any): validator is import("yup").Schema<T>;
-export declare function isSuperstructSchema<T>(validator: any): validator is import("superstruct").Struct<T, any>;
+export {};

dist/types/index.js

@@ -1,9 +0,1 @@
-export function isZodSchema(validator) {
-    return validator && typeof validator.parse === 'function' && typeof validator.safeParse === 'function';
-}
-export function isYupSchema(validator) {
-    return validator instanceof (require("yup").Schema);
-}
-export function isSuperstructSchema(validator) {
-    return validator instanceof (require("superstruct").Struct);
-}
+export {};

dist/utils.d.ts

@@ -1,3 +0,1 @@
-export declare function bracketIndexToDot(path: string): string;
-export declare function errorPathObjectify(errors: Record<string, string>): Record<string, any>;
-export declare function createErrorProxy(obj: any, isRoot?: boolean): any;
+export * from './utils/getResolver';

dist/utils.js

@@ -1,71 +0,1 @@
-export function bracketIndexToDot(path) {
-    let newPath = path.replace(/\[(\d+)\]/g, '.$1');
-    newPath = newPath.replace(/\.{2,}/g, '.');
-    if (newPath.startsWith('.'))
-        newPath = newPath.slice(1);
-    return newPath;
-}
-export function errorPathObjectify(errors) {
-    const result = {};
-    for (const key in errors) {
-        const value = errors[key];
-        const path = key.split(".");
-        let temp = result;
-        path.forEach((segment, idx) => {
-            if (idx === path.length - 1) {
-                if (segment === "root") {
-                    temp[segment] = value;
-                }
-                else {
-                    temp[segment] = { root: value };
-                }
-            }
-            else {
-                if (!temp[segment] || typeof temp[segment] !== "object") {
-                    temp[segment] = {};
-                }
-                temp = temp[segment];
-            }
-        });
-    }
-    return result;
-}
-export function createErrorProxy(obj, isRoot = true) {
-    if (typeof obj !== "object" || obj === null)
-        return obj;
-    return new Proxy(obj, {
-        get(target, prop, receiver) {
-            if (isRoot && (prop === Symbol.toStringTag || prop === Symbol.iterator || prop === "constructor")) {
-                return Reflect.get(target, prop, receiver);
-            }
-            if (prop === Symbol.iterator) {
-                return undefined;
-            }
-            if (typeof prop === "string" && Object.prototype.hasOwnProperty.call(target, prop)) {
-                const value = target[prop];
-                if (typeof value === "object" && value !== null) {
-                    if ("root" in value) {
-                        return value.root;
-                    }
-                    return createErrorProxy(value, false);
-                }
-                return value;
-            }
-            return Reflect.get(target, prop, receiver);
-        },
-        set(target, prop, value, receiver) {
-            console.warn(`오류 객체의 "${String(prop)}" 속성은 수정할 수 없습니다.`);
-            return false;
-        },
-        deleteProperty(target, prop) {
-            console.warn(`오류 객체의 "${String(prop)}" 속성은 삭제할 수 없습니다.`);
-            return false;
-        },
-        ownKeys(target) {
-            return Reflect.ownKeys(target);
-        },
-        getOwnPropertyDescriptor(target, prop) {
-            return Object.getOwnPropertyDescriptor(target, prop);
-        }
-    });
-}
+export * from './utils/getResolver';

package.json

 {
   "name": "common-resolver",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "scripts": {
@@ -15,16 +15,16 @@ "build": "tsc"
     "./zod": {
-      "import": "./dist/exports/zodResolver.js",
-      "types": "./dist/exports/zodResolver.d.ts"
+      "import": "./dist/exports/zod.js",
+      "types": "./dist/exports/zod.d.ts"
     },
     "./yup": {
-      "import": "./dist/exports/yupResolver.js",
-      "types": "./dist/exports/yupResolver.d.ts"
+      "import": "./dist/exports/yup.js",
+      "types": "./dist/exports/yup.d.ts"
     },
     "./superstruct": {
-      "import": "./dist/exports/ssResolver.js",
-      "types": "./dist/exports/ssResolver.d.ts"
+      "import": "./dist/exports/superstruct.js",
+      "types": "./dist/exports/superstruct.d.ts"
     },
-    "./getResolver": {
-      "import": "./dist/exports/getResolver.js",
-      "types": "./dist/exports/getResolver.d.ts"
+    "./utils": {
+      "import": "./dist/exports/utils.js",
+      "types": "./dist/exports/utils.d.ts"
     },
@@ -48,13 +48,2 @@ "./types": {
   },
-  "peerDependenciesMeta": {
-    "zod": {
-      "optional": true
-    },
-    "yup": {
-      "optional": true
-    },
-    "superstruct": {
-      "optional": true
-    }
-  },
   "devDependencies": {
@@ -70,4 +59,7 @@ "@types/node": "^22.9.0",
     "vite": "^5.2.10",
-    "vite-plugin-compression": "^0.5.1"
+    "vite-plugin-compression": "^0.5.1",
+    "zod": "^3.0.0",
+    "yup": "^1.0.0",
+    "superstruct": "^2.0.0"
   }
 }

dist/core.d.ts

-import { Resolver, ValidateSchema } from "./types";
-export declare function getResolver<T>(validator: ValidateSchema<T>[keyof ValidateSchema<T>]): Resolver<T>;
-export declare function zodResolver<T>(schema: ValidateSchema<T>["zod"]): Resolver<T>;
-export declare function yupResolver<T>(schema: ValidateSchema<T>["yup"]): Resolver<T>;
-export declare function superstructResolver<T>(schema: ValidateSchema<T>["superstruct"]): Resolver<T>;

dist/core.js

-import { isZodSchema, isYupSchema, isSuperstructSchema } from "./typeGuards";
-import { validate } from "superstruct";
-import { bracketIndexToDot, createErrorProxy, errorPathObjectify } from "./utils";
-export function getResolver(validator) {
-    if (isZodSchema(validator)) {
-        return zodResolver(validator);
-    }
-    else if (isYupSchema(validator)) {
-        return yupResolver(validator);
-    }
-    else if (isSuperstructSchema(validator)) {
-        return superstructResolver(validator);
-    }
-    else {
-        throw new Error("Unsupported validation library");
-    }
-}
-export function zodResolver(schema) {
-    const formatter = (obj) => {
-        return obj.reduce((acc, { message, path }) => {
-            acc[path.join('.') || "root"] = message;
-            return acc;
-        }, {});
-    };
-    return {
-        validate: (state) => {
-            const result = schema.safeParse(state);
-            if (result.success) {
-                return {
-                    valid: true,
-                    error: null,
-                };
-            }
-            else {
-                return {
-                    valid: false,
-                    error: createErrorProxy(errorPathObjectify(formatter(result.error.issues))),
-                };
-            }
-        }
-    };
-}
-export function yupResolver(schema) {
-    const formatter = (e) => {
-        return e.reduce((acc, err) => {
-            acc[bracketIndexToDot(err.path) || "root"] = err.errors[0];
-            return acc;
-        }, {});
-    };
-    return {
-        validate: (state) => {
-            try {
-                schema.validateSync(state, { abortEarly: false });
-                return {
-                    valid: true,
-                    error: null,
-                };
-            }
-            catch (e) {
-                return {
-                    valid: false,
-                    error: createErrorProxy(errorPathObjectify(formatter(e.inner)))
-                };
-            }
-        }
-    };
-}
-export function superstructResolver(schema) {
-    const formatter = (obj) => {
-        return obj.reduce((acc, { message, path }) => {
-            acc[path.join('.') || "root"] = message;
-            return acc;
-        }, {});
-    };
-    return {
-        validate: (state) => {
-            const [error] = validate(state, schema);
-            if (!error) {
-                return {
-                    valid: true,
-                    error: null,
-                };
-            }
-            else {
-                return {
-                    valid: false,
-                    error: createErrorProxy(errorPathObjectify(formatter(error.failures()))),
-                };
-            }
-        }
-    };
-}

dist/exports/getResolver.d.ts

-export * from "../resolver/getResolver";

dist/exports/getResolver.js

-export * from "../resolver/getResolver";

dist/exports/ssResolver.d.ts

-export { superstructResolver } from "../resolver/ssResolver";
-export { isSuperstructSchema } from "../type";
-export { superstructParser } from "../parser/ssParser";

dist/exports/ssResolver.js

-export { superstructResolver } from "../resolver/ssResolver";
-export { isSuperstructSchema } from "../type";
-export { superstructParser } from "../parser/ssParser";

dist/exports/yupResolver.d.ts

-export { yupResolver } from "../resolver/yupResolver";
-export { isYupSchema } from "../type";
-export { yupParser } from "../parser/yupParser";

dist/exports/yupResolver.js

-export { yupResolver } from "../resolver/yupResolver";
-export { isYupSchema } from "../type";
-export { yupParser } from "../parser/yupParser";

dist/exports/zodResolver.d.ts

-export { zodResolver } from "../resolver/zodResolver";
-export { isZodSchema } from "../type";
-export { zodParser } from "../parser/zodParser";

dist/exports/zodResolver.js

-export { zodResolver } from "../resolver/zodResolver";
-export { isZodSchema } from "../type";
-export { zodParser } from "../parser/zodParser";

dist/index.d.ts

-export * from "./core";

dist/index.js

-export * from "./core";

dist/parser/commonParser.d.ts

-import { Resolver, ValidateSchema } from "../type";
-export declare function commonParser<T, K extends ValidateSchema<T>[keyof ValidateSchema<T>]>(data: T, schema: K, resolver: (schema: K) => Resolver<T>, options?: {
-    throwError: boolean;
-}): T;

dist/parser/commonParser.js

-export function commonParser(data, schema, resolver, options) {
-    const result = resolver(schema).validate(data);
-    if (!result.valid) {
-        if (options?.throwError) {
-            throw result.error;
-        }
-        else {
-            return data;
-        }
-    }
-    return data;
-}

dist/parser/ssParser.d.ts

-import { ValidateSchema } from "../type";
-export declare function superstructParser<T>(data: T, schema: ValidateSchema<T>["superstruct"], options?: {
-    throwError: boolean;
-}): T;

dist/parser/ssParser.js

-import { superstructResolver } from "../resolver/ssResolver";
-import { commonParser } from "./commonParser";
-export function superstructParser(data, schema, options) {
-    return commonParser(data, schema, superstructResolver, options);
-}

dist/parser/yupParser.d.ts

-import { ValidateSchema } from "../type";
-export declare function yupParser<T>(data: T, schema: ValidateSchema<T>["yup"], options?: {
-    throwError: boolean;
-}): T;

dist/parser/yupParser.js

-import { yupResolver } from "../resolver/yupResolver";
-import { commonParser } from "./commonParser";
-export function yupParser(data, schema, options) {
-    return commonParser(data, schema, yupResolver, options);
-}

dist/parser/zodParser.d.ts

-import { ValidateSchema } from "../type";
-export declare function zodParser<T>(data: T, schema: ValidateSchema<T>["zod"], options?: {
-    throwError: boolean;
-}): T;

dist/parser/zodParser.js

-import { zodResolver } from "../resolver/zodResolver";
-import { commonParser } from "./commonParser";
-export function zodParser(data, schema, options) {
-    return commonParser(data, schema, zodResolver, options);
-}

dist/resolver/getResolver.d.ts

-import { ValidateSchema, Resolver } from "../type";
-export declare function getResolver<T>(validator: ValidateSchema<T>[keyof ValidateSchema<T>]): Resolver<T>;

dist/resolver/getResolver.js

-import { isZodSchema, isYupSchema, isSuperstructSchema } from "../type";
-import { superstructResolver } from "./ssResolver";
-import { yupResolver } from "./yupResolver";
-import { zodResolver } from "./zodResolver";
-export function getResolver(validator) {
-    if (isZodSchema(validator)) {
-        return zodResolver(validator);
-    }
-    else if (isYupSchema(validator)) {
-        return yupResolver(validator);
-    }
-    else if (isSuperstructSchema(validator)) {
-        return superstructResolver(validator);
-    }
-    else {
-        throw new Error("Unsupported validation library");
-    }
-}

dist/resolver/ssResolver.d.ts

-import { Resolver, ValidateSchema } from "../type";
-export declare function superstructResolver<T>(schema: ValidateSchema<T>["superstruct"]): Resolver<T>;

dist/resolver/ssResolver.js

-import { createErrorProxy, errorPathObjectify } from "../utils";
-export function superstructResolver(schema) {
-    const { validate } = require("superstruct");
-    const formatter = (obj) => {
-        return obj.reduce((acc, { message, path }) => {
-            acc[path.join('.') || "root"] = message;
-            return acc;
-        }, {});
-    };
-    return {
-        validate: (state) => {
-            const [error] = validate(state, schema);
-            if (!error) {
-                return {
-                    valid: true,
-                    error: null,
-                    data: state
-                };
-            }
-            else {
-                return {
-                    valid: false,
-                    error: createErrorProxy(errorPathObjectify(formatter(error.failures()))),
-                    data: null
-                };
-            }
-        }
-    };
-}

dist/resolver/yupResolver.d.ts

-import { ValidateSchema, Resolver } from "../type";
-export declare function yupResolver<T>(schema: ValidateSchema<T>["yup"]): Resolver<T>;

dist/resolver/yupResolver.js

-import { bracketIndexToDot, createErrorProxy, errorPathObjectify } from "../utils";
-export function yupResolver(schema) {
-    const formatter = (e) => {
-        return e.reduce((acc, err) => {
-            acc[bracketIndexToDot(err.path) || "root"] = err.errors[0];
-            return acc;
-        }, {});
-    };
-    return {
-        validate: (state) => {
-            try {
-                schema.validateSync(state, { abortEarly: false });
-                return {
-                    valid: true,
-                    error: null,
-                    data: state
-                };
-            }
-            catch (e) {
-                return {
-                    valid: false,
-                    error: createErrorProxy(errorPathObjectify(formatter(e.inner))),
-                    data: null
-                };
-            }
-        }
-    };
-}

dist/resolver/zodResolver.d.ts

-import { Resolver, ValidateSchema } from "../type";
-export declare function zodResolver<T>(schema: ValidateSchema<T>["zod"]): Resolver<T>;

dist/resolver/zodResolver.js

-import { createErrorProxy, errorPathObjectify } from "../utils";
-export function zodResolver(schema) {
-    const formatter = (obj) => {
-        return obj.reduce((acc, { message, path }) => {
-            acc[path.join('.') || "root"] = message;
-            return acc;
-        }, {});
-    };
-    return {
-        validate: (state) => {
-            const result = schema.safeParse(state);
-            if (result.success) {
-                return {
-                    valid: true,
-                    error: null,
-                    data: state
-                };
-            }
-            else {
-                return {
-                    valid: false,
-                    error: createErrorProxy(errorPathObjectify(formatter(result.error.issues))),
-                    data: null
-                };
-            }
-        }
-    };
-}

dist/type/index.d.ts

-export type ValidateSchema<T> = {
-    zod: import("zod").ZodSchema<T>;
-    yup: import("yup").Schema<T>;
-    superstruct: import("superstruct").Struct<T, any>;
-};
-export type RecursivePartial<T> = {
-    [P in keyof T]?: T[P] extends object ? RecursivePartial<T[P]> : string;
-};
-type CRES<T> = RecursivePartial<T> & {
-    "root"?: string;
-};
-export type Resolver<T> = {
-    validate: (state: T, name?: string) => {
-        valid: true;
-        error: null;
-        data: T;
-    } | {
-        valid: false;
-        error: CRES<T>;
-        data: null;
-    };
-};
-export declare function isZodSchema<T>(validator: any): validator is import("zod").ZodSchema<T>;
-export declare function isYupSchema<T>(validator: any): validator is import("yup").Schema<T>;
-export declare function isSuperstructSchema<T>(validator: any): validator is import("superstruct").Struct<T, any>;
-export {};

dist/type/index.js

-export function isZodSchema(validator) {
-    return validator && typeof validator.parse === 'function' && typeof validator.safeParse === 'function';
-}
-export function isYupSchema(validator) {
-    return validator instanceof (require("yup").Schema);
-}
-export function isSuperstructSchema(validator) {
-    return validator instanceof (require("superstruct").Struct);
-}

dist/typeGuards.d.ts

-export declare function isZodSchema<T>(validator: any): validator is import("zod").ZodSchema<T>;
-export declare function isYupSchema<T>(validator: any): validator is import("yup").Schema<T>;
-export declare function isSuperstructSchema<T>(validator: any): validator is import("superstruct").Struct<T, any>;

dist/typeGuards.js

-export function isZodSchema(validator) {
-    return validator && typeof validator.parse === 'function' && typeof validator.safeParse === 'function';
-}
-export function isYupSchema(validator) {
-    return validator instanceof (require("yup").Schema);
-}
-export function isSuperstructSchema(validator) {
-    return validator instanceof (require("superstruct").Struct);
-}

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Improved metrics

Number of package files

56

27.27%

Worsened metrics

Total package byte prevSize

31928

-16.8%

Dev dependency count

13

30%

Lines of code

357

-33.02%

Number of medium supply chain risk alerts

1

Infinity%

No dependency changes