@quentinadam/zod 0.1.1

package/README.md

@@ -0,0 +1,24 @@
+# @quentinadam/zod
+
+[![JSR][jsr-image]][jsr-url] [![NPM][npm-image]][npm-url] [![CI][ci-image]][ci-url]
+
+A simple library to parse data, inspired by [https://zod.dev/](zod).
+
+## Usage
+
+```ts
+import * as z from '@quentinadam/zod';
+
+const data: unknown = { age: 30, name: 'John', email: 'john@example.com' };
+
+const schema: z.Schema<{ age: number; name: string }> = z.object({ age: z.number(), name: z.string() });
+
+const parsed: { age: number; name: string } = schema.parse(data);
+```
+
+[ci-image]: https://img.shields.io/github/actions/workflow/status/quentinadam/deno-zod/ci.yml?branch=main&logo=github&style=flat-square
+[ci-url]: https://github.com/quentinadam/deno-zod/actions/workflows/ci.yml
+[npm-image]: https://img.shields.io/npm/v/@quentinadam/zod.svg?style=flat-square
+[npm-url]: https://npmjs.org/package/@quentinadam/zod
+[jsr-image]: https://jsr.io/badges/@quentinadam/zod?style=flat-square
+[jsr-url]: https://jsr.io/@quentinadam/zod

package/dist/zod.d.ts

@@ -0,0 +1,57 @@
+export declare class Schema<T> {
+    #private;
+    readonly inputType: string;
+    constructor({ inputType, parseFn }: {
+        inputType: string;
+        parseFn: (value: unknown) => T;
+    });
+    parse(value: unknown): T;
+    safeParse(value: unknown): {
+        success: true;
+        data: T;
+    } | {
+        success: false;
+        error: unknown;
+    };
+    transform<U>(transform: (value: T) => U): Schema<U>;
+    optional(): Schema<T | undefined>;
+    nullable(): Schema<T | null>;
+}
+export declare class ObjectSchema<T extends Record<string, unknown>> extends Schema<T> {
+    #private;
+    constructor(schema: {
+        [K in keyof T]: Schema<T[K]>;
+    }, strict?: boolean);
+    extend<U extends Record<string, unknown>>(newSchema: {
+        [K in keyof U]: Schema<U[K]>;
+    }): ObjectSchema<T & U>;
+    strict(): ObjectSchema<T>;
+    strip(): ObjectSchema<T>;
+    partial(): ObjectSchema<{
+        [K in keyof T]: T[K] | undefined;
+    }>;
+}
+declare function createStringSchema(): Schema<string>;
+declare function createNumberSchema(): Schema<number>;
+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]>;
+}): 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 createRecordSchema<T>(schema: Schema<T>): Schema<Record<string, T>>;
+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, };

package/dist/zod.js

@@ -0,0 +1,252 @@
+export class Schema {
+    #parseFn;
+    inputType;
+    constructor({ inputType, parseFn }) {
+        this.#parseFn = parseFn;
+        this.inputType = inputType;
+    }
+    parse(value) {
+        return this.#parseFn(value);
+    }
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error };
+        }
+    }
+    transform(transform) {
+        return new Schema({ inputType: this.inputType, parseFn: (value) => transform(this.parse(value)) });
+    }
+    optional() {
+        return new Schema({
+            inputType: `${this.inputType} | undefined`,
+            parseFn: (value) => value === undefined ? undefined : this.parse(value),
+        });
+    }
+    nullable() {
+        return new Schema({
+            inputType: `${this.inputType} | null`,
+            parseFn: (value) => value === null ? null : this.parse(value),
+        });
+    }
+}
+export class ObjectSchema extends Schema {
+    #schema;
+    #strict;
+    constructor(schema, strict = false) {
+        const inputType = `{ ${Object.entries(schema).map(([key, schema]) => `"${key}": ${schema.inputType}`).join(', ')} }`;
+        super({
+            inputType,
+            parseFn: (value) => {
+                if (typeof value !== 'object' || value === null) {
+                    throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+                }
+                return ((value) => {
+                    if (strict) {
+                        for (const key of Object.keys(value)) {
+                            if (!(key in schema)) {
+                                throw new Error(`Expected strict ${this.inputType}, got ${JSON.stringify(value)}`);
+                            }
+                        }
+                    }
+                    const result = {};
+                    Object.entries(schema).forEach(([key, schema]) => {
+                        result[key] = schema.parse(value[key]);
+                    });
+                    return result;
+                })(value);
+            },
+        });
+        this.#schema = schema;
+        this.#strict = strict;
+    }
+    extend(newSchema) {
+        return new ObjectSchema({ ...this.#schema, ...newSchema }, this.#strict);
+    }
+    strict() {
+        return new ObjectSchema(this.#schema, true);
+    }
+    strip() {
+        return new ObjectSchema(this.#schema, false);
+    }
+    partial() {
+        const schema = Object.fromEntries(Object.entries(this.#schema).map(([key, schema]) => [key, schema.optional()]));
+        return new ObjectSchema(schema, this.#strict);
+    }
+}
+function createStringSchema() {
+    const inputType = 'string';
+    return new Schema({
+        inputType,
+        parseFn: (value) => {
+            if (typeof value !== 'string') {
+                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+            }
+            return value;
+        },
+    });
+}
+function createNumberSchema() {
+    const inputType = 'number';
+    return new Schema({
+        inputType,
+        parseFn: (value) => {
+            if (typeof value !== 'number') {
+                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+            }
+            return value;
+        },
+    });
+}
+function createBigIntSchema() {
+    const inputType = 'bigint';
+    return new Schema({
+        inputType,
+        parseFn: (value) => {
+            if (typeof value !== 'bigint') {
+                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+            }
+            return value;
+        },
+    });
+}
+function createUnknownSchema() {
+    const inputType = 'unknown';
+    return new Schema({
+        inputType,
+        parseFn: (value) => {
+            return value;
+        },
+    });
+}
+function createBooleanSchema() {
+    const inputType = 'boolean';
+    return new Schema({
+        inputType,
+        parseFn: (value) => {
+            if (typeof value !== 'boolean') {
+                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+            }
+            return value;
+        },
+    });
+}
+function createNullSchema() {
+    const inputType = 'null';
+    return new Schema({
+        inputType,
+        parseFn: (value) => {
+            if (value !== null) {
+                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+            }
+            return value;
+        },
+    });
+}
+function createUndefinedSchema() {
+    const inputType = 'undefined';
+    return new Schema({
+        inputType,
+        parseFn: (value) => {
+            if (value !== undefined) {
+                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+            }
+            return value;
+        },
+    });
+}
+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 createTupleSchema(schema) {
+    const inputType = `[ ${schema.map((schema) => schema.inputType).join(', ')} ]`;
+    return new Schema({
+        inputType,
+        parseFn: (value) => {
+            if (!Array.isArray(value) || value.length !== schema.length) {
+                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+            }
+            return schema.map((schema, index) => schema.parse(value[index]));
+        },
+    });
+}
+function createObjectSchema(schema) {
+    return new ObjectSchema(schema);
+}
+function createInstanceofSchema(schema) {
+    const inputType = schema.name;
+    return new Schema({
+        inputType,
+        parseFn: (value) => {
+            if (!(value instanceof schema)) {
+                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+            }
+            return value;
+        },
+    });
+}
+function createArraySchema(schema) {
+    const inputType = `Array<${schema.inputType}>`;
+    return new Schema({
+        inputType,
+        parseFn: (value) => {
+            if (!Array.isArray(value)) {
+                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+            }
+            return value.map((item) => schema.parse(item));
+        },
+    });
+}
+function createRecordSchema(schema) {
+    const inputType = `Record<string, ${schema.inputType}>`;
+    return new Schema({
+        inputType,
+        parseFn: (value) => {
+            if (typeof value !== 'object' || value === null) {
+                throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+            }
+            return Object.fromEntries(Object.entries(value).map(([key, value]) => [key, schema.parse(value)]));
+        },
+    });
+}
+function createUnionSchema(schemas) {
+    const inputType = schemas.map((schema) => schema.inputType).join(' | ');
+    return new Schema({
+        inputType,
+        parseFn: (value) => {
+            for (const schema of schemas) {
+                try {
+                    return schema.parse(value);
+                }
+                catch (_) {
+                    continue;
+                }
+            }
+            throw new Error(`Expected ${inputType}, got ${JSON.stringify(value)}`);
+        },
+    });
+}
+function createLiteralSchema(value) {
+    const inputType = JSON.stringify(value);
+    return new Schema({
+        inputType,
+        parseFn: (input) => {
+            if (input !== value) {
+                throw new Error(`Expected ${inputType}, got ${input}`);
+            }
+            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, };

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@quentinadam/zod",
+  "version": "0.1.1",
+  "description": "A simple library to parse data, inspired by zod",
+  "license": "MIT",
+  "author": "Quentin Adam",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/quentinadam/deno-zod.git"
+  },
+  "type": "module",
+  "exports": "./dist/zod.js",
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}