@quentinadam/zod 0.1.1 → 0.1.3

package/dist/zod.d.ts

@@ -31,27 +31,28 @@ export declare class ObjectSchema<T extends Record<string, unknown>> extends Sch
         [K in keyof T]: T[K] | undefined;
     }>;
 }
-declare function createStringSchema(): Schema<string>;
-declare function createNumberSchema(): Schema<number>;
+declare function createArraySchema<T>(schema: Schema<T>): Schema<T[]>;
 declare function createBigIntSchema(): Schema<bigint>;
-declare function createUnknownSchema(): Schema<unknown>;
 declare function createBooleanSchema(): Schema<boolean>;
-declare function createNullSchema(): Schema<null>;
-declare function createUndefinedSchema(): Schema<undefined>;
 declare function createDateSchema(): Schema<Date>;
-declare function createTupleSchema<T extends unknown[]>(schema: {
-    [K in keyof T]: Schema<T[K]>;
+declare function createInstanceofSchema<T>(schema: {
+    new (...args: any[]): T;
 }): Schema<T>;
+declare function createLazySchema<T>(fn: () => Schema<T>): Schema<T>;
+declare function createLiteralSchema<T extends string | number | boolean | null>(litteral: T): Schema<T>;
 declare function createObjectSchema<T extends Record<string, unknown>>(schema: {
     [K in keyof T]: Schema<T[K]>;
 }): ObjectSchema<T>;
-declare function createInstanceofSchema<T>(schema: {
-    new (...args: unknown[]): T;
-}): Schema<T>;
-declare function createArraySchema<T>(schema: Schema<T>): Schema<T[]>;
+declare function createNullSchema(): Schema<null>;
+declare function createNumberSchema(): Schema<number>;
 declare function createRecordSchema<T>(schema: Schema<T>): Schema<Record<string, T>>;
+declare function createStringSchema(): Schema<string>;
+declare function createTupleSchema<T extends unknown[]>(schema: {
+    [K in keyof T]: Schema<T[K]>;
+}): Schema<T>;
+declare function createUndefinedSchema(): Schema<undefined>;
 declare function createUnionSchema<T extends unknown[]>(schemas: {
     [K in keyof T]: Schema<T[K]>;
 }): Schema<T[number]>;
-declare function createLiteralSchema<T extends string | number | boolean | null>(value: T): Schema<T>;
-export { createArraySchema as array, createBigIntSchema as bigint, createBooleanSchema as boolean, createDateSchema as date, createInstanceofSchema as instanceof, createLiteralSchema as literal, createNullSchema as null, createNumberSchema as number, createObjectSchema as object, createRecordSchema as record, createStringSchema as string, createTupleSchema as tuple, createUndefinedSchema as undefined, createUnionSchema as union, createUnknownSchema as unknown, };
+declare function createUnknownSchema(): Schema<unknown>;
+export { createArraySchema as array, createBigIntSchema as bigint, createBooleanSchema as boolean, createDateSchema as date, createInstanceofSchema as instanceof, createLazySchema as lazy, createLiteralSchema as literal, createNullSchema as null, createNumberSchema as number, createObjectSchema as object, createRecordSchema as record, createStringSchema as string, createTupleSchema as tuple, createUndefinedSchema as undefined, createUnionSchema as union, createUnknownSchema as unknown, };

package/dist/zod.js

@@ -76,147 +76,157 @@ export class ObjectSchema extends Schema {
         return new ObjectSchema(schema, this.#strict);
     }
 }
-function createStringSchema() {
-    const inputType = 'string';
+function createArraySchema(schema) {
+    const inputType = `Array<${schema.inputType}>`;
     return new Schema({
         inputType,
         parseFn: (value) => {
-            if (typeof value !== 'string') {
+            if (!Array.isArray(value)) {
                 throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
             }
-            return value;
+            return value.map((item) => schema.parse(item));
         },
     });
 }
-function createNumberSchema() {
-    const inputType = 'number';
+function createBigIntSchema() {
+    const inputType = 'bigint';
     return new Schema({
         inputType,
         parseFn: (value) => {
-            if (typeof value !== 'number') {
+            if (typeof value !== 'bigint') {
                 throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
             }
             return value;
         },
     });
 }
-function createBigIntSchema() {
-    const inputType = 'bigint';
+function createBooleanSchema() {
+    const inputType = 'boolean';
     return new Schema({
         inputType,
         parseFn: (value) => {
-            if (typeof value !== 'bigint') {
+            if (typeof value !== 'boolean') {
                 throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
             }
             return value;
         },
     });
 }
-function createUnknownSchema() {
-    const inputType = 'unknown';
+function createDateSchema() {
+    const inputType = 'Date';
     return new Schema({
         inputType,
         parseFn: (value) => {
+            if (!(value instanceof Date)) {
+                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+            }
             return value;
         },
     });
 }
-function createBooleanSchema() {
-    const inputType = 'boolean';
+// deno-lint-ignore no-explicit-any
+function createInstanceofSchema(schema) {
+    const inputType = schema.name;
     return new Schema({
         inputType,
         parseFn: (value) => {
-            if (typeof value !== 'boolean') {
+            if (!(value instanceof schema)) {
                 throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
             }
             return value;
         },
     });
 }
-function createNullSchema() {
-    const inputType = 'null';
+function createLazySchema(fn) {
+    return new Schema({
+        inputType: '(lazy)',
+        parseFn: (value) => fn().parse(value),
+    });
+}
+function createLiteralSchema(litteral) {
+    const inputType = JSON.stringify(litteral);
     return new Schema({
         inputType,
         parseFn: (value) => {
-            if (value !== null) {
+            if (value !== litteral) {
                 throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
             }
-            return value;
+            return litteral;
         },
     });
 }
-function createUndefinedSchema() {
-    const inputType = 'undefined';
+function createObjectSchema(schema) {
+    return new ObjectSchema(schema);
+}
+function createNullSchema() {
+    const inputType = 'null';
     return new Schema({
         inputType,
         parseFn: (value) => {
-            if (value !== undefined) {
+            if (value !== null) {
                 throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
             }
             return value;
         },
     });
 }
-function createDateSchema() {
-    const inputType = 'Date';
+function createNumberSchema() {
+    const inputType = 'number';
     return new Schema({
         inputType,
         parseFn: (value) => {
-            if (!(value instanceof Date)) {
+            if (typeof value !== 'number') {
                 throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
             }
             return value;
         },
     });
 }
-function createTupleSchema(schema) {
-    const inputType = `[ ${schema.map((schema) => schema.inputType).join(', ')} ]`;
+function createRecordSchema(schema) {
+    const inputType = `Record<string, ${schema.inputType}>`;
     return new Schema({
         inputType,
         parseFn: (value) => {
-            if (!Array.isArray(value) || value.length !== schema.length) {
+            if (typeof value !== 'object' || value === null) {
                 throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
             }
-            return schema.map((schema, index) => schema.parse(value[index]));
+            return Object.fromEntries(Object.entries(value).map(([key, value]) => [key, schema.parse(value)]));
         },
     });
 }
-function createObjectSchema(schema) {
-    return new ObjectSchema(schema);
-}
-function createInstanceofSchema(schema) {
-    const inputType = schema.name;
+function createStringSchema() {
+    const inputType = 'string';
     return new Schema({
         inputType,
         parseFn: (value) => {
-            if (!(value instanceof schema)) {
+            if (typeof value !== 'string') {
                 throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
             }
             return value;
         },
     });
 }
-function createArraySchema(schema) {
-    const inputType = `Array<${schema.inputType}>`;
+function createTupleSchema(schema) {
+    const inputType = `[ ${schema.map((schema) => schema.inputType).join(', ')} ]`;
     return new Schema({
         inputType,
         parseFn: (value) => {
-            if (!Array.isArray(value)) {
+            if (!Array.isArray(value) || value.length !== schema.length) {
                 throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
             }
-            return value.map((item) => schema.parse(item));
+            return schema.map((schema, index) => schema.parse(value[index]));
         },
     });
 }
-function createRecordSchema(schema) {
-    const inputType = `Record<string, ${schema.inputType}>`;
+function createUndefinedSchema() {
+    const inputType = 'undefined';
     return new Schema({
         inputType,
         parseFn: (value) => {
-            if (typeof value !== 'object' || value === null) {
+            if (value !== undefined) {
                 throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
             }
-            return Object.fromEntries(Object.entries(value).map(([key, value]) => [key, schema.parse(value)]));
+            return value;
         },
     });
 }
@@ -237,16 +247,13 @@ function createUnionSchema(schemas) {
         },
     });
 }
-function createLiteralSchema(value) {
-    const inputType = JSON.stringify(value);
+function createUnknownSchema() {
+    const inputType = 'unknown';
     return new Schema({
         inputType,
-        parseFn: (input) => {
-            if (input !== value) {
-                throw new Error(`Expected ${inputType}, got ${input}`);
-            }
+        parseFn: (value) => {
             return value;
         },
     });
 }
-export { createArraySchema as array, createBigIntSchema as bigint, createBooleanSchema as boolean, createDateSchema as date, createInstanceofSchema as instanceof, createLiteralSchema as literal, createNullSchema as null, createNumberSchema as number, createObjectSchema as object, createRecordSchema as record, createStringSchema as string, createTupleSchema as tuple, createUndefinedSchema as undefined, createUnionSchema as union, createUnknownSchema as unknown, };
+export { createArraySchema as array, createBigIntSchema as bigint, createBooleanSchema as boolean, createDateSchema as date, createInstanceofSchema as instanceof, createLazySchema as lazy, createLiteralSchema as literal, createNullSchema as null, createNumberSchema as number, createObjectSchema as object, createRecordSchema as record, createStringSchema as string, createTupleSchema as tuple, createUndefinedSchema as undefined, createUnionSchema as union, createUnknownSchema as unknown, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quentinadam/zod",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "A simple library to parse data, inspired by zod",
   "license": "MIT",
   "author": "Quentin Adam",