0.1.3 (#4)

Co-authored-by: Julien Valverdé <julien.valverde@mailo.com>
Reviewed-on: https://git.jvalver.de/Thilawyn/zod-schema-class/pulls/4

.drone.jsonnet

@@ -16,8 +16,8 @@ local lint_step = {
 
 local build_step = {
     name: "build",
-    image: bun_image,
+    image: node_image,
-    commands: ["bun run build"],
+    commands: ["npm run build"],
 };
 
 local pack_step = {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thilawyn/zod-schema-class",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "module",
   "publishConfig": {
     "registry": "https://git.jvalver.de/api/packages/thilawyn/npm/"
@@ -8,11 +8,12 @@
   "files": [
     "./dist"
   ],
+  "types": "./dist/lib.d.ts",
   "exports": {
     ".": {
       "import": {
-        "types": "./dist/lib.d.mts",
+        "types": "./dist/lib.d.ts",
-        "default": "./dist/lib.mjs"
+        "default": "./dist/lib.js"
       },
       "require": {
         "types": "./dist/lib.d.cts",
@@ -21,42 +22,45 @@
     },
     "./schema": {
       "import": {
-        "types": "./dist/schema.d.mts",
+        "types": "./dist/schema/lib.d.ts",
-        "default": "./dist/schema.mjs"
+        "default": "./dist/schema/lib.js"
       },
       "require": {
-        "types": "./dist/schema.d.cts",
+        "types": "./dist/schema/lib.d.cts",
-        "default": "./dist/schema.cjs"
+        "default": "./dist/schema/lib.cjs"
       }
     }
   },
   "scripts": {
-    "build": "rollup -c rollup.config.ts",
+    "build": "tsup",
     "lint:tsc": "tsc --noEmit",
     "clean:cache": "rm -f tsconfig.tsbuildinfo",
     "clean:dist": "rm -rf dist",
     "clean:node": "rm -rf node_modules"
   },
   "dependencies": {
-    "@thilawyn/traitify-ts": "^0.1.15",
+    "@thilawyn/traitify-ts": "^0.1.19",
-    "decimal.js": "^10.4.3",
-    "effect": "^2.4.3",
     "lodash-es": "^4.17.21",
-    "mobx": "^6.12.0",
+    "type-fest": "^4.14.0",
-    "type-fest": "^4.12.0",
     "zod": "^3.22.4"
   },
+  "peerDependencies": {
+    "mobx": "^6.12.1",
+    "decimal.js": "^10.4.3",
+    "effect": "^2.4.11"
+  },
+  "peerDependenciesMeta": {
+    "mobx": { "optional": true },
+    "decimal.js": { "optional": true },
+    "effect": { "optional": true }
+  },
   "devDependencies": {
-    "@rollup/plugin-node-resolve": "^15.2.3",
     "@types/lodash-es": "^4.17.12",
     "bun-types": "latest",
-    "npm-check-updates": "^16.14.15",
+    "npm-check-updates": "^16.14.17",
     "npm-sort": "^0.0.4",
-    "rollup": "^4.12.1",
+    "tsup": "^8.0.2",
-    "rollup-plugin-cleanup": "^3.2.1",
-    "rollup-plugin-ts": "^3.4.5",
-    "ts-functional-pipe": "^3.1.2",
     "tsx": "^4.7.1",
-    "typescript": "^5.4.2"
+    "typescript": "^5.4.3"
   }
 }

rollup.config.ts

@@ -1,43 +0,0 @@
-import { nodeResolve } from "@rollup/plugin-node-resolve"
-import { defineConfig } from "rollup"
-import cleanup from "rollup-plugin-cleanup"
-import ts from "rollup-plugin-ts"
-import pkg from "./package.json" assert { type: "json" }
-
-
-export const createBundleConfig = (
-    input:  string,
-    name:   keyof typeof pkg.exports,
-) =>
-    defineConfig({
-        input,
-
-        output: [
-            {
-                file:    pkg.exports[name].import.default,
-                format:  "esm",
-            },
-            {
-                file:    pkg.exports[name].require.default,
-                format:  "cjs",
-            },
-        ],
-
-        external: id => !/^[./]/.test(id),
-
-        plugins: [
-            nodeResolve(),
-            ts(),
-
-            cleanup({
-                comments: "jsdoc",
-                extensions: ["ts"],
-            }),
-        ],
-    })
-
-
-export default [
-    createBundleConfig("src/lib.ts", "."),
-    createBundleConfig("src/schema/lib.ts", "./schema"),
-]

src/ExtendZodSchemaClass.ts

@@ -0,0 +1,56 @@
+import { TraitInstance, TraitStaticMembers, expression } from "@thilawyn/traitify-ts"
+import { AbstractClass } from "type-fest"
+import { z } from "zod"
+import { ZodSchemaObject, ZodSchemaObjectTrait } from "./traits/ZodSchemaObject"
+import { Extend, StaticMembers } from "./util"
+
+
+export function ExtendZodSchemaClass<
+    Self extends (
+        AbstractClass<
+            Values & TraitInstance<ZodSchemaObjectTrait<T, Catchall, Values, PartialValues>>,
+            [values: Values]
+        > &
+        TraitStaticMembers<ZodSchemaObjectTrait<T, Catchall, Values, PartialValues>>
+    ),
+
+    T                     extends z.ZodRawShape,
+    Catchall              extends z.ZodTypeAny,
+    Values                extends object,
+    PartialValues         extends Partial<Values>,
+
+    ExtendedT             extends z.ZodRawShape,
+    ExtendedCatchall      extends z.ZodTypeAny,
+    ExtendedValues        extends Values,
+    ExtendedPartialValues extends Partial<ExtendedValues>,
+>(
+    class_: Self | (
+        AbstractClass<
+            Values & TraitInstance<ZodSchemaObjectTrait<T, Catchall, Values, PartialValues>>,
+            [values: Values]
+        > &
+        TraitStaticMembers<ZodSchemaObjectTrait<T, Catchall, Values, PartialValues>>
+    ),
+
+    schemaWithDefaults: (
+        schemaWithDefaults: z.ZodObject<T, "strip", Catchall, Values, PartialValues>
+    ) => z.ZodObject<ExtendedT, "strip", ExtendedCatchall, ExtendedValues, ExtendedPartialValues>,
+) {
+    return expression
+        .extends(
+            class_ as (
+                AbstractClass<
+                    Omit<
+                        Extend<[InstanceType<Self>, ExtendedValues]>,
+                        keyof TraitInstance<ZodSchemaObjectTrait<T, Catchall, Values, PartialValues>>
+                    >,
+                    [values: ExtendedValues]
+                > &
+                Omit<
+                    StaticMembers<Self>,
+                    keyof TraitStaticMembers<ZodSchemaObjectTrait<T, Catchall, Values, PartialValues>>
+                >
+            )
+        )
+        .expresses(ZodSchemaObject(schemaWithDefaults((class_ as Self).schemaWithDefaults)))
+}

src/JsonifiedZodSchemaClass.ts

@@ -0,0 +1,42 @@
+import { expression } from "@thilawyn/traitify-ts"
+import { Class, Jsonifiable } from "type-fest"
+import { z } from "zod"
+import { JsonifiedZodSchemaObject, OfClass, OfClassInstance } from "./traits/JsonifiedZodSchemaObject"
+
+
+export function JsonifiedZodSchemaClass<
+    Of                extends OfClass<OfInstance, T, Catchall, Values, PartialValues>,
+    OfInstance        extends OfClassInstance<T, Catchall, Values, PartialValues>,
+    T                 extends z.ZodRawShape,
+    Catchall          extends z.ZodTypeAny,
+    Values            extends object,
+    PartialValues     extends Partial<Values>,
+
+    JsonifyT          extends z.ZodRawShape,
+    JsonifyCatchall   extends z.ZodTypeAny,
+    DejsonifyT        extends z.ZodRawShape,
+    DejsonifyCatchall extends z.ZodTypeAny,
+    JsonifiedValues   extends object & Jsonifiable,
+>(
+    of: Of | OfClass<OfInstance, T, Catchall, Values, PartialValues>,
+
+    props: {
+        jsonifySchema: (
+            schema: typeof of.schema
+        ) => z.ZodObject<JsonifyT, "strip", JsonifyCatchall, JsonifiedValues, Values>,
+
+        dejsonifySchema: (
+            schema: typeof of.schema
+        ) => z.ZodObject<DejsonifyT, "strip", DejsonifyCatchall, Values, JsonifiedValues>,
+    },
+) {
+    return expression
+        .extends(
+            class JsonifiedZodSchemaObjectConstructor {
+                constructor(values: JsonifiedValues) {
+                    Object.assign(this, values)
+                }
+            } as Class<JsonifiedValues, [values: JsonifiedValues]>
+        )
+        .expresses(JsonifiedZodSchemaObject(of as Of, props))
+}

src/ZodSchemaClass.ts

@@ -0,0 +1,24 @@
+import { expression } from "@thilawyn/traitify-ts"
+import { Class } from "type-fest"
+import { z } from "zod"
+import { ZodSchemaObject } from "./traits/ZodSchemaObject"
+
+
+export function ZodSchemaClass<
+    T             extends z.ZodRawShape,
+    Catchall      extends z.ZodTypeAny,
+    Values        extends object,
+    PartialValues extends Partial<Values>,
+>(
+    schemaWithDefaults: z.ZodObject<T, "strip", Catchall, Values, PartialValues>
+) {
+    return expression
+        .extends(
+            class ZodSchemaObjectConstructor {
+                constructor(values: Values) {
+                    Object.assign(this, values)
+                }
+            } as Class<Values, [values: Values]>
+        )
+        .expresses(ZodSchemaObject(schemaWithDefaults))
+}

src/builders/ZodSchemaClassBuilder.ts

@@ -1,133 +0,0 @@
-import { Trait, TraitExpressionBuilder, expression } from "@thilawyn/traitify-ts"
-import { AbstractClass } from "type-fest"
-import { EmptyObject } from "type-fest/source/empty-object"
-import { JsonifiableObject } from "type-fest/source/jsonifiable"
-import { z } from "zod"
-import { JsonifiableZodSchemaObject } from "../traits/JsonifiableZodSchemaObject"
-import { ZodSchemaObject } from "../traits/ZodSchemaObject"
-
-
-export class ZodSchemaClassBuilder<
-    Superclass   extends AbstractClass<object>,
-    const Traits extends readonly Trait<any, any, any, any>[],
-    Schemas      extends object,
-> {
-    declare ["constructor"]: typeof ZodSchemaClassBuilder
-
-    constructor(
-        protected readonly expression:  TraitExpressionBuilder<Superclass, Traits>,
-        protected readonly schemas:     Schemas,
-    ) {}
-
-
-    schema<
-        SchemaT                            extends z.ZodRawShape,
-        SchemaUnknownKeys                  extends z.UnknownKeysParam,
-        SchemaCatchall                     extends z.ZodTypeAny,
-
-        SchemaWithDefaultValuesT           extends z.ZodRawShape,
-        SchemaWithDefaultValuesUnknownKeys extends z.UnknownKeysParam,
-        SchemaWithDefaultValuesCatchall    extends z.ZodTypeAny,
-
-        Values                             extends object,
-        PartialValues                      extends Partial<Values>,
-    >(
-        this: ZodSchemaClassBuilder<Superclass, Traits, EmptyObject>,
-
-        props: {
-            schema: z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
-
-            schemaWithDefaultValues: (
-                schema: z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
-            ) => z.ZodObject<SchemaWithDefaultValuesT, SchemaWithDefaultValuesUnknownKeys, SchemaWithDefaultValuesCatchall, Values, PartialValues>
-        },
-    ) {
-        const schema                  = props.schema
-        const schemaWithDefaultValues = props.schemaWithDefaultValues(props.schema)
-
-        abstract class ZodSchemaObjectConstructor {
-            constructor(values: Values) {
-                Object.assign(this, values)
-            }
-        }
-
-        return new this.constructor(
-            this.expression
-                .extends(ZodSchemaObjectConstructor as AbstractClass<Values, [values: Values]>)
-                .expresses(ZodSchemaObject(schema, schemaWithDefaultValues)),
-
-            { schema, schemaWithDefaultValues } as const,
-        )
-    }
-
-    jsonifiable<
-        S extends {
-            readonly schema:                   z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>,
-            readonly schemaWithDefaultValues:  z.ZodObject<SchemaWithDefaultValuesT, SchemaWithDefaultValuesUnknownKeys, SchemaWithDefaultValuesCatchall, Values, PartialValues>,
-            jsonifySchema?:                    never
-            dejsonifySchema?:                  never
-        },
-
-        SchemaT                            extends z.ZodRawShape,
-        SchemaUnknownKeys                  extends z.UnknownKeysParam,
-        SchemaCatchall                     extends z.ZodTypeAny,
-
-        SchemaWithDefaultValuesT           extends z.ZodRawShape,
-        SchemaWithDefaultValuesUnknownKeys extends z.UnknownKeysParam,
-        SchemaWithDefaultValuesCatchall    extends z.ZodTypeAny,
-
-        Values                             extends object,
-        PartialValues                      extends Partial<Values>,
-
-        JsonifySchemaT                     extends z.ZodRawShape,
-        JsonifySchemaUnknownKeys           extends z.UnknownKeysParam,
-        JsonifySchemaCatchall              extends z.ZodTypeAny,
-
-        DejsonifySchemaT                   extends z.ZodRawShape,
-        DejsonifySchemaUnknownKeys         extends z.UnknownKeysParam,
-        DejsonifySchemaCatchall            extends z.ZodTypeAny,
-
-        JsonifiedValues                    extends JsonifiableObject,
-    >(
-        this: ZodSchemaClassBuilder<Superclass, Traits, S | {
-            readonly schema:                   z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>,
-            readonly schemaWithDefaultValues:  z.ZodObject<SchemaWithDefaultValuesT, SchemaWithDefaultValuesUnknownKeys, SchemaWithDefaultValuesCatchall, Values, PartialValues>,
-            jsonifySchema?:                    never
-            dejsonifySchema?:                  never
-        }>,
-
-        props: {
-            jsonifySchema: (
-                schema: z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
-            ) => z.ZodObject<JsonifySchemaT, JsonifySchemaUnknownKeys, JsonifySchemaCatchall, JsonifiedValues, Values>
-
-            dejsonifySchema: (
-                schema: z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
-            ) => z.ZodObject<DejsonifySchemaT, DejsonifySchemaUnknownKeys, DejsonifySchemaCatchall, Values, JsonifiedValues>
-        },
-    ) {
-        const jsonifySchema   = props.jsonifySchema(this.schemas.schema)
-        const dejsonifySchema = props.dejsonifySchema(this.schemas.schema)
-
-        return new this.constructor(
-            this.expression.expresses(
-                JsonifiableZodSchemaObject(
-                    this.schemas.schema,
-                    this.schemas.schemaWithDefaultValues,
-                    jsonifySchema,
-                    dejsonifySchema,
-                )
-            ),
-
-            { ...this.schemas as S, jsonifySchema, dejsonifySchema } as const,
-        )
-    }
-
-
-    toExpression() {
-        return this.expression
-    }
-}
-
-
-export const zodSchemaClass = new ZodSchemaClassBuilder(expression, {})

src/builders/ZodSchemaClassExtender.ts

@@ -1,196 +0,0 @@
-// import { expression } from "@thilawyn/traitify-ts"
-// import { AbstractClass, Simplify } from "type-fest"
-// import { JsonifiableObject } from "type-fest/source/jsonifiable"
-// import { z } from "zod"
-// import { JsonifiableZodSchemaAbstractClass } from "../shapes/JsonifiableZodSchemaClass"
-// import { ZodSchemaAbstractClass } from "../shapes/ZodSchemaClass"
-// import { Extend, Override, StaticMembers } from "../util"
-
-
-// export class ZodSchemaClassExtender<
-//     Superclass extends AbstractClass<object>,
-//     Subclass   extends AbstractClass<object>,
-// > {
-//     declare ["constructor"]: typeof ZodSchemaClassExtender
-
-//     constructor(
-//         readonly superclass:  Superclass,
-//         readonly subclass:    Subclass,
-//     ) {}
-
-
-//     schema<
-//         Super                  extends ZodSchemaAbstractClass<any, SuperSchemaT, SuperSchemaUnknownKeys, SuperSchemaCatchall, SuperValues, SuperDefaultValues>,
-
-//         SuperSchemaT           extends z.ZodRawShape,
-//         SuperSchemaUnknownKeys extends z.UnknownKeysParam,
-//         SuperSchemaCatchall    extends z.ZodTypeAny,
-
-//         SuperValues            extends object,
-//         SuperDefaultValues     extends Partial<SuperValues>,
-
-//         SchemaT                extends z.ZodRawShape,
-//         SchemaUnknownKeys      extends z.UnknownKeysParam,
-//         SchemaCatchall         extends z.ZodTypeAny,
-
-//         Values                 extends SuperValues,
-//         DefaultValues          extends Partial<Values>,
-//     >(
-//         this: ZodSchemaClassExtender<
-//             Super | ZodSchemaAbstractClass<any, SuperSchemaT, SuperSchemaUnknownKeys, SuperSchemaCatchall, SuperValues, SuperDefaultValues>,
-//             any
-//         >,
-
-//         props: {
-//             schema:         (schema: Super["schema"]) => z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
-//             defaultValues:  (defaultValues: SuperDefaultValues) => DefaultValues
-//         },
-//     ) {
-//         const schema        = props.schema(this.superclass.schema)
-//         const defaultValues = props.defaultValues(this.superclass.defaultValues)
-
-//         class Schemas extends (this.superclass as AbstractClass<object, any[]>) {
-//             static readonly schema        = schema
-//             static readonly defaultValues = defaultValues
-//         }
-
-//         return new this.constructor(
-//             this.superclass as Super,
-
-//             Schemas as unknown as AbstractClass<
-//                 Simplify<
-//                     Extend<[InstanceType<Super>, Values]>
-//                 >,
-
-//                 [values: Values]
-//             > &
-//             Simplify<
-//                 Override<[
-//                     StaticMembers<Super>,
-//                     StaticMembers<typeof Schemas>,
-//                 ]>
-//             >
-//         )
-//     }
-
-//     jsonifiable<
-//         /** Superclass jsonifiable schemas */
-//         Super                           extends JsonifiableZodSchemaAbstractClass<
-//             any,
-
-//             SuperJsonifySchemaT,
-//             SuperJsonifySchemaUnknownKeys,
-//             SuperJsonifySchemaCatchall,
-
-//             SuperDejsonifySchemaT,
-//             SuperDejsonifySchemaUnknownKeys,
-//             SuperDejsonifySchemaCatchall,
-
-//             SuperJsonifiedValues,
-//             SuperValues
-//         >,
-
-//         SuperJsonifySchemaT             extends z.ZodRawShape,
-//         SuperJsonifySchemaUnknownKeys   extends z.UnknownKeysParam,
-//         SuperJsonifySchemaCatchall      extends z.ZodTypeAny,
-
-//         SuperDejsonifySchemaT           extends z.ZodRawShape,
-//         SuperDejsonifySchemaUnknownKeys extends z.UnknownKeysParam,
-//         SuperDejsonifySchemaCatchall    extends z.ZodTypeAny,
-
-//         SuperJsonifiedValues            extends JsonifiableObject,
-//         SuperValues                     extends object,
-
-//         /** New schemas */
-//         Self                           extends ZodSchemaAbstractClass<any, SelfSchemaT, SelfSchemaUnknownKeys, SelfSchemaCatchall, SelfValues, SelfDefaultValues>,
-
-//         SelfSchemaT                    extends z.ZodRawShape,
-//         SelfSchemaUnknownKeys          extends z.UnknownKeysParam,
-//         SelfSchemaCatchall             extends z.ZodTypeAny,
-
-//         SelfValues                     extends object,
-//         SelfDefaultValues              extends Partial<SelfValues>,
-
-//         /* New jsonifiable schemas */
-//         JsonifySchemaT                  extends z.ZodRawShape,
-//         JsonifySchemaUnknownKeys        extends z.UnknownKeysParam,
-//         JsonifySchemaCatchall           extends z.ZodTypeAny,
-
-//         DejsonifySchemaT                extends z.ZodRawShape,
-//         DejsonifySchemaUnknownKeys      extends z.UnknownKeysParam,
-//         DejsonifySchemaCatchall         extends z.ZodTypeAny,
-
-//         JsonifiedValues                 extends SuperJsonifiedValues,
-//         Values                          extends SelfValues,
-//     >(
-//         this: ZodSchemaClassExtender<
-//             Super | JsonifiableZodSchemaAbstractClass<
-//                 any,
-
-//                 SuperJsonifySchemaT,
-//                 SuperJsonifySchemaUnknownKeys,
-//                 SuperJsonifySchemaCatchall,
-
-//                 SuperDejsonifySchemaT,
-//                 SuperDejsonifySchemaUnknownKeys,
-//                 SuperDejsonifySchemaCatchall,
-
-//                 SuperJsonifiedValues,
-//                 SuperValues
-//             >,
-
-//             Self | ZodSchemaAbstractClass<any, SelfSchemaT, SelfSchemaUnknownKeys, SelfSchemaCatchall, SelfValues, SelfDefaultValues>
-//         >,
-
-//         props: {
-//             jsonifySchema: (
-//                 schema:         Self["schema"],
-//                 jsonifySchema:  Super["jsonifySchema"],
-//             ) => z.ZodObject<JsonifySchemaT, JsonifySchemaUnknownKeys, JsonifySchemaCatchall, JsonifiedValues, Values>
-
-//             dejsonifySchema: (
-//                 schema:           Self["schema"],
-//                 dejsonifySchema:  Super["dejsonifySchema"],
-//             ) => z.ZodObject<DejsonifySchemaT, DejsonifySchemaUnknownKeys, DejsonifySchemaCatchall, Values, JsonifiedValues>
-//         },
-//     ) {
-//         const jsonifySchema   = props.jsonifySchema(this.subclass.schema, this.superclass.jsonifySchema)
-//         const dejsonifySchema = props.dejsonifySchema(this.subclass.schema, this.superclass.dejsonifySchema)
-
-//         class JsonifiableSchemas extends (this.subclass as AbstractClass<object>) {
-//             static readonly jsonifySchema   = jsonifySchema
-//                    readonly jsonifySchema   = jsonifySchema
-//             static readonly dejsonifySchema = dejsonifySchema
-//                    readonly dejsonifySchema = dejsonifySchema
-//         }
-
-//         return new this.constructor(
-//             this.superclass as Super,
-
-//             JsonifiableSchemas as unknown as AbstractClass<
-//                 Simplify<
-//                     Override<[InstanceType<Self>, JsonifiableSchemas]>
-//                 >,
-
-//                 ConstructorParameters<
-//                     ZodSchemaAbstractClass<any, SelfSchemaT, SelfSchemaUnknownKeys, SelfSchemaCatchall, SelfValues, SelfDefaultValues>
-//                 >
-//             > &
-//             Simplify<
-//                 Override<[
-//                     StaticMembers<Self>,
-//                     StaticMembers<typeof JsonifiableSchemas>,
-//                 ]>
-//             >,
-//         )
-//     }
-
-
-//     toClass() {
-//         return this.subclass
-//     }
-
-//     toExpressionBuilder() {
-//         return expression.extends(this.subclass)
-//     }
-// }

src/lib.ts

@@ -1,4 +1,6 @@
-export { ZodSchemaClassBuilder, zodSchemaClass } from "./builders/ZodSchemaClassBuilder"
+export { ExtendZodSchemaClass } from "./ExtendZodSchemaClass"
-export { JsonifiableZodSchemaObject } from "./traits/JsonifiableZodSchemaObject"
+export { JsonifiedZodSchemaClass } from "./JsonifiedZodSchemaClass"
+export { ZodSchemaClass } from "./ZodSchemaClass"
+export { JsonifiedZodSchemaObject } from "./traits/JsonifiedZodSchemaObject"
 export { MobXObservableZodSchemaObject } from "./traits/MobXObservableZodSchemaObject"
 export { ZodSchemaObject, ZodSchemaObjectTrait } from "./traits/ZodSchemaObject"

src/schema/bigint.ts

@@ -0,0 +1,19 @@
+import { z } from "zod"
+
+
+type JsonifiedBigIntBrand = "@thilawyn/zod-schema-class/JsonifiedBigInt"
+
+
+export function jsonify<S extends z.ZodType<bigint>>(schema: S) {
+    return schema
+        .transform(v => v.toString())
+        .brand<JsonifiedBigIntBrand>()
+}
+
+export function dejsonify<S extends z.ZodType<bigint>>(schema: S) {
+    return z
+        .custom<string & z.BRAND<JsonifiedBigIntBrand>>()
+        .pipe(z.string())
+        .pipe(z.coerce.bigint())
+        .pipe(schema)
+}

src/schema/date.ts

@@ -0,0 +1,19 @@
+import { z } from "zod"
+
+
+type JsonifiedDateBrand = "@thilawyn/zod-schema-class/JsonifiedDate"
+
+
+export function jsonify<S extends z.ZodType<Date>>(schema: S) {
+    return schema
+        .transform(v => v.toString())
+        .brand<JsonifiedDateBrand>()
+}
+
+export function dejsonify<S extends z.ZodType<Date>>(schema: S) {
+    return z
+        .custom<string & z.BRAND<JsonifiedDateBrand>>()
+        .pipe(z.string())
+        .pipe(z.coerce.date())
+        .pipe(schema)
+}

src/schema/decimal.ts

@@ -0,0 +1,36 @@
+import Decimal from "decimal.js"
+import { z } from "zod"
+
+
+type JsonifiedDecimalBrand = "@thilawyn/zod-schema-class/JsonifiedDecimal"
+
+
+export function decimal() {
+    return z.custom<Decimal>(v => Decimal.isDecimal(v))
+}
+
+export module decimal {
+    export function jsonifyDecimalSchema<S extends z.ZodType<Decimal>>(schema: S) {
+        return schema
+            .transform(v => v.toJSON())
+            .brand<JsonifiedDecimalBrand>()
+    }
+
+    export function dejsonifyDecimalSchema<S extends z.ZodType<Decimal>>(schema: S) {
+        return z
+            .custom<string & z.BRAND<JsonifiedDecimalBrand>>()
+            .pipe(
+                z
+                    .string()
+                    .transform(v => {
+                        try {
+                            return new Decimal(v)
+                        }
+                        catch (e) {
+                            return v
+                        }
+                    })
+            )
+            .pipe(schema)
+    }
+}

src/schema/effect/index.ts

@@ -1,6 +1 @@
-import { option } from "./option"
+export { option } from "./option"
-
-
-export const effect = {
-    option,
-} as const

src/schema/effect/option.ts

@@ -3,19 +3,144 @@ import { identity } from "lodash-es"
 import { z } from "zod"
 
 
-export const option = {
+type JsonifiedEffectOptionSomeBrand = "@thilawyn/zod-schema-class/JsonifiedEffectOptionSome"
-    option: <S extends z.ZodSchema>(schema: S) =>
-        z.union([option.some(schema), option.none(schema)]),
 
-    some: <S extends z.ZodSchema>(schema: S) => z
-        .custom<Option.Some<z.output<S>>>(v => Option.isOption(v) && Option.isSome(v), "Not an Option")
-        .pipe(z.object({ value: schema }).passthrough())
-        .transform<Option.Some<z.output<S>>>(identity),
 
-    none: <S extends z.ZodSchema | unknown = unknown>(_schema?: S) =>
+export function option<InnerS extends z.ZodTypeAny>(schema: InnerS) {
-        z.custom<Option.None<
+    return z.union([option.some(schema), option.none(schema)])
-            S extends z.ZodSchema
+}
-                ? z.output<S>
+
-                : unknown
+export module option {
-        >>(v => Option.isOption(v) && Option.isNone(v), "Not an Option"),
+    export type Option<InnerS extends z.ZodTypeAny> = ReturnType<typeof option<InnerS>>
-} as const
+
+    function getSomeSchema<InnerS extends z.ZodTypeAny>(schema: Option<InnerS>): some.Some<InnerS> {
+        return schema.options[0]
+    }
+    function getNoneSchema<InnerS extends z.ZodTypeAny>(schema: Option<InnerS>): none.None<InnerS> {
+        return schema.options[1]
+    }
+
+
+    export function jsonify<
+        InnerS          extends z.ZodTypeAny,
+        JsonifiedInnerS extends z.ZodTypeAny = InnerS,
+    >(
+        schema:         Option<InnerS>,
+        jsonifySchema:  (schema: InnerS) => JsonifiedInnerS = identity,
+    ) {
+        return z.union([
+            some.jsonify(getSomeSchema(schema), jsonifySchema),
+            none.jsonify(getNoneSchema(schema), jsonifySchema),
+        ])
+    }
+
+    export function dejsonify<
+        InnerS            extends z.ZodTypeAny,
+        DejsonifiedInnerS extends z.ZodTypeAny = InnerS,
+    >(
+        schema:           Option<InnerS>,
+        dejsonifySchema:  (schema: InnerS) => DejsonifiedInnerS = identity,
+    ) {
+        return z.union([
+            some.dejsonify(getSomeSchema(schema), dejsonifySchema),
+            none.dejsonify(getNoneSchema(schema), dejsonifySchema),
+        ])
+    }
+
+
+    export function some<
+        InnerS extends z.ZodTypeAny
+    >(
+        schema: InnerS
+    ) {
+        return z
+            .custom<Option.Some<z.output<InnerS>>>(
+                v => Option.isOption(v) && Option.isSome(v),
+                "Not an Option.Some",
+            )
+            .pipe(z.object({ value: schema }).passthrough())
+            .transform(v => Option.some<z.output<InnerS>>(v.value))
+    }
+
+    export module some {
+        export type Some<InnerS extends z.ZodTypeAny> = ReturnType<typeof some<InnerS>>
+
+        function getInnerSchema<InnerS extends z.ZodTypeAny>(schema: Some<InnerS>): InnerS {
+            return schema._def.schema._def.out.shape.value
+        }
+
+
+        export function jsonify<
+            InnerS          extends z.ZodTypeAny,
+            JsonifiedInnerS extends z.ZodTypeAny = InnerS,
+        >(
+            schema:         Some<InnerS>,
+            jsonifySchema:  (schema: InnerS) => JsonifiedInnerS = identity,
+        ) {
+            return schema
+                .transform(v => Option.getOrThrow(v))
+                .pipe(jsonifySchema(getInnerSchema(schema)))
+                .brand<JsonifiedEffectOptionSomeBrand>()
+        }
+
+        export function dejsonify<
+            InnerS            extends z.ZodTypeAny,
+            DejsonifiedInnerS extends z.ZodTypeAny = InnerS,
+        >(
+            schema:           Some<InnerS>,
+            dejsonifySchema:  (schema: InnerS) => DejsonifiedInnerS = identity,
+        ) {
+            return z
+                .custom<z.input<DejsonifiedInnerS> & z.BRAND<JsonifiedEffectOptionSomeBrand>>()
+                .pipe(dejsonifySchema(getInnerSchema(schema)))
+                .transform(v => Option.some<z.output<DejsonifiedInnerS>>(v))
+                .pipe(schema)
+        }
+    }
+
+
+    export function none<
+        InnerS extends z.ZodTypeAny | unknown = unknown
+    >(
+        _schema?: InnerS
+    ) {
+        return z.custom<
+            Option.None<
+                InnerS extends z.ZodTypeAny
+                    ? z.output<InnerS>
+                    : unknown
+            >
+        >(
+            v => Option.isOption(v) && Option.isNone(v),
+            "Not an Option.None",
+        )
+    }
+
+    export module none {
+        export type None<InnerS extends z.ZodTypeAny> = ReturnType<typeof none<InnerS>>
+
+
+        export function jsonify<
+            InnerS          extends z.ZodTypeAny,
+            JsonifiedInnerS extends z.ZodTypeAny = InnerS,
+        >(
+            schema:           None<InnerS>,
+            _jsonifySchema?:  (schema: InnerS) => JsonifiedInnerS,
+        ) {
+            return schema.transform(() => null)
+        }
+
+        export function dejsonify<
+            InnerS            extends z.ZodTypeAny,
+            DejsonifiedInnerS extends z.ZodTypeAny = InnerS,
+        >(
+            schema:             None<InnerS>,
+            _dejsonifySchema?:  (schema: InnerS) => DejsonifiedInnerS,
+        ) {
+            return z
+                .null()
+                .transform(() => Option.none<z.output<DejsonifiedInnerS>>())
+                .pipe(schema)
+        }
+    }
+}

src/schema/jsonifiable/bigint.ts

@@ -1,28 +0,0 @@
-import { identity } from "lodash-es"
-import { Opaque } from "type-fest"
-import { z } from "zod"
-
-
-export type JsonifiedBigInt = Opaque<string, "@thilawyn/zod-schema-class/JsonifiedBigInt">
-
-
-export function jsonifyBigIntSchema<S extends z.ZodBigInt>(schema: S) {
-    return schema.transform(v => v.toString() as JsonifiedBigInt)
-}
-
-export function dejsonifyBigIntSchema<S extends z.ZodBigInt>(schema: S) {
-    return z
-        .custom<JsonifiedBigInt>(identity)
-        .pipe(z
-            .string()
-            .transform(v => {
-                try {
-                    return BigInt(v)
-                }
-                catch (e) {
-                    return v
-                }
-            })
-            .pipe(schema)
-        )
-}

src/schema/jsonifiable/date.ts

@@ -1,28 +0,0 @@
-import { identity } from "lodash-es"
-import { Opaque } from "type-fest"
-import { z } from "zod"
-
-
-export type JsonifiedDate = Opaque<string, "@thilawyn/zod-schema-class/JsonifiedDate">
-
-
-export function jsonifyDateSchema<S extends z.ZodDate>(schema: S) {
-    return schema.transform(v => v.toString() as JsonifiedDate)
-}
-
-export function dejsonifyDateSchema<S extends z.ZodDate>(schema: S) {
-    return z
-        .custom<JsonifiedDate>(identity)
-        .pipe(z
-            .string()
-            .transform(v => {
-                try {
-                    return new Date(v)
-                }
-                catch (e) {
-                    return v
-                }
-            })
-            .pipe(schema)
-        )
-}

src/schema/jsonifiable/decimal.ts

@@ -1,33 +0,0 @@
-import { Decimal } from "decimal.js"
-import { identity } from "lodash-es"
-import { Opaque } from "type-fest"
-import { z } from "zod"
-
-
-export type JsonifiedDecimal = Opaque<string, "@thilawyn/zod-schema-class/JsonifiedDecimal">
-
-
-export function jsonifyDecimalSchema<
-    S extends z.ZodType<Decimal, z.ZodTypeDef, Decimal>
->(schema: S) {
-    return schema.transform(v => v.toJSON() as JsonifiedDecimal)
-}
-
-export function dejsonifyDecimalSchema<
-    S extends z.ZodType<Decimal, z.ZodTypeDef, Decimal>
->(schema: S) {
-    return z
-        .custom<JsonifiedDecimal>(identity)
-        .pipe(z
-            .string()
-            .transform(v => {
-                try {
-                    return new Decimal(v)
-                }
-                catch (e) {
-                    return v
-                }
-            })
-            .pipe(schema)
-        )
-}

src/schema/jsonifiable/index.ts

@@ -1,16 +0,0 @@
-import { dejsonifyBigIntSchema, jsonifyBigIntSchema } from "./bigint"
-import { dejsonifyDateSchema, jsonifyDateSchema } from "./date"
-import { dejsonifyDecimalSchema, jsonifyDecimalSchema } from "./decimal"
-
-
-export const jsonify = {
-    bigint:   jsonifyBigIntSchema,
-    date:     jsonifyDateSchema,
-    decimal:  jsonifyDecimalSchema,
-} as const
-
-export const dejsonify = {
-    bigint:   dejsonifyBigIntSchema,
-    date:     dejsonifyDateSchema,
-    decimal:  dejsonifyDecimalSchema,
-} as const

src/schema/lib.ts

@@ -1,2 +1,12 @@
-export * from "./effect"
+import * as bigint from "./bigint"
-export * from "./jsonifiable"
+import * as date from "./date"
+import { decimal } from "./decimal"
+import * as effect from "./effect"
+
+
+export const s = {
+    bigint,
+    date,
+    decimal,
+    effect,
+} as const

src/shapes/JsonifiableZodSchemaClass.ts

@@ -1,78 +0,0 @@
-import { AbstractClass, Class } from "type-fest"
-import { JsonifiableObject } from "type-fest/source/jsonifiable"
-import { z } from "zod"
-
-
-export type JsonifiableZodSchemaClass<
-    Instance                   extends Values,
-
-    JsonifySchemaT             extends z.ZodRawShape,
-    JsonifySchemaUnknownKeys   extends z.UnknownKeysParam,
-    JsonifySchemaCatchall      extends z.ZodTypeAny,
-
-    DejsonifySchemaT           extends z.ZodRawShape,
-    DejsonifySchemaUnknownKeys extends z.UnknownKeysParam,
-    DejsonifySchemaCatchall    extends z.ZodTypeAny,
-
-    JsonifiedValues            extends JsonifiableObject,
-    Values                     extends object,
-> = (
-    Class<Instance, [values: Values]> &
-    JsonifiableZodSchemas<
-        JsonifySchemaT,
-        JsonifySchemaUnknownKeys,
-        JsonifySchemaCatchall,
-
-        DejsonifySchemaT,
-        DejsonifySchemaUnknownKeys,
-        DejsonifySchemaCatchall,
-
-        JsonifiedValues,
-        Values
-    >
-)
-
-export type JsonifiableZodSchemaAbstractClass<
-    Instance                   extends Values,
-
-    JsonifySchemaT             extends z.ZodRawShape,
-    JsonifySchemaUnknownKeys   extends z.UnknownKeysParam,
-    JsonifySchemaCatchall      extends z.ZodTypeAny,
-
-    DejsonifySchemaT           extends z.ZodRawShape,
-    DejsonifySchemaUnknownKeys extends z.UnknownKeysParam,
-    DejsonifySchemaCatchall    extends z.ZodTypeAny,
-
-    JsonifiedValues            extends JsonifiableObject,
-    Values                     extends object,
-> = (
-    AbstractClass<Instance, [values: Values]> &
-    JsonifiableZodSchemas<
-        JsonifySchemaT,
-        JsonifySchemaUnknownKeys,
-        JsonifySchemaCatchall,
-
-        DejsonifySchemaT,
-        DejsonifySchemaUnknownKeys,
-        DejsonifySchemaCatchall,
-
-        JsonifiedValues,
-        Values
-    >
-)
-
-export type JsonifiableZodSchemas<
-    JsonifySchemaT             extends z.ZodRawShape,
-    JsonifySchemaUnknownKeys   extends z.UnknownKeysParam,
-    JsonifySchemaCatchall      extends z.ZodTypeAny,
-
-    DejsonifySchemaT           extends z.ZodRawShape,
-    DejsonifySchemaUnknownKeys extends z.UnknownKeysParam,
-    DejsonifySchemaCatchall    extends z.ZodTypeAny,
-
-    JsonifiedValues            extends JsonifiableObject,
-    Values                     extends object,
-> = {
-    readonly jsonifySchema:    z.ZodObject<JsonifySchemaT, JsonifySchemaUnknownKeys, JsonifySchemaCatchall, JsonifiedValues, Values>
-    readonly dejsonifySchema:  z.ZodObject<DejsonifySchemaT, DejsonifySchemaUnknownKeys, DejsonifySchemaCatchall, Values, JsonifiedValues>
-}

src/shapes/ZodSchemaClass.ts

@@ -1,55 +0,0 @@
-import { AbstractClass, Class } from "type-fest"
-import { z } from "zod"
-
-
-export type ZodSchemaClass<
-    Instance                           extends Values,
-
-    SchemaT                            extends z.ZodRawShape,
-    SchemaUnknownKeys                  extends z.UnknownKeysParam,
-    SchemaCatchall                     extends z.ZodTypeAny,
-
-    SchemaWithDefaultValuesT           extends z.ZodRawShape,
-    SchemaWithDefaultValuesUnknownKeys extends z.UnknownKeysParam,
-    SchemaWithDefaultValuesCatchall    extends z.ZodTypeAny,
-
-    Values                             extends object,
-    PartialValues                      extends Partial<Values>,
-> = (
-    Class<Instance, [values: Values]> &
-    ZodSchemas<SchemaT, SchemaUnknownKeys, SchemaCatchall, SchemaWithDefaultValuesT, SchemaWithDefaultValuesUnknownKeys, SchemaWithDefaultValuesCatchall, Values, PartialValues>
-)
-
-export type ZodSchemaAbstractClass<
-    Instance                           extends Values,
-
-    SchemaT                            extends z.ZodRawShape,
-    SchemaUnknownKeys                  extends z.UnknownKeysParam,
-    SchemaCatchall                     extends z.ZodTypeAny,
-
-    SchemaWithDefaultValuesT           extends z.ZodRawShape,
-    SchemaWithDefaultValuesUnknownKeys extends z.UnknownKeysParam,
-    SchemaWithDefaultValuesCatchall    extends z.ZodTypeAny,
-
-    Values                             extends object,
-    PartialValues                      extends Partial<Values>,
-> = (
-    AbstractClass<Instance, [values: Values]> &
-    ZodSchemas<SchemaT, SchemaUnknownKeys, SchemaCatchall, SchemaWithDefaultValuesT, SchemaWithDefaultValuesUnknownKeys, SchemaWithDefaultValuesCatchall, Values, PartialValues>
-)
-
-export type ZodSchemas<
-    SchemaT                            extends z.ZodRawShape,
-    SchemaUnknownKeys                  extends z.UnknownKeysParam,
-    SchemaCatchall                     extends z.ZodTypeAny,
-
-    SchemaWithDefaultValuesT           extends z.ZodRawShape,
-    SchemaWithDefaultValuesUnknownKeys extends z.UnknownKeysParam,
-    SchemaWithDefaultValuesCatchall    extends z.ZodTypeAny,
-
-    Values                             extends object,
-    PartialValues                      extends Partial<Values>,
-> = {
-    readonly schema:                   z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>
-    readonly schemaWithDefaultValues:  z.ZodObject<SchemaWithDefaultValuesT, SchemaWithDefaultValuesUnknownKeys, SchemaWithDefaultValuesCatchall, Values, PartialValues>
-}

src/tests.ts

@@ -1,64 +1,60 @@
 import { Implements } from "@thilawyn/traitify-ts"
+import { Option } from "effect"
 import { z } from "zod"
-import { zodSchemaClass } from "./builders/ZodSchemaClassBuilder"
+import { ExtendZodSchemaClass } from "./ExtendZodSchemaClass"
-import { dejsonify, jsonify } from "./schema/jsonifiable"
+import { JsonifiedZodSchemaClass } from "./JsonifiedZodSchemaClass"
+import { ZodSchemaClass } from "./ZodSchemaClass"
+import { s } from "./schema/lib"
 import { MobXObservableZodSchemaObject } from "./traits/MobXObservableZodSchemaObject"
 
 
-const exp = zodSchemaClass
+const userExp = ZodSchemaClass(
-    .schema({
+    z.object({
-        schema: z.object({
+        /** User ID */
-            /** User ID */
+        id: s.effect.option(z.bigint()).default(Option.none()),
-            id: z.bigint(),
 
-            /** Username */
+        /** Username */
-            name: z.string(),
+        name: z.string(),
-        }),
 
-        schemaWithDefaultValues: s => s.extend({
+        /** Role */
-            id: s.shape.id.default(-1n),
+        role: z.enum(["User", "Moderator", "Admin"]).default("User"),
-        }),
     })
-    .jsonifiable({
+)
-        jsonifySchema: s => s.extend({
-            id: jsonify.bigint(s.shape.id)
-        }),
-
-        dejsonifySchema: s => s.extend({
-            id: dejsonify.bigint(s.shape.id)
-        }),
-    })
-    .toExpression()
     .expresses(MobXObservableZodSchemaObject)
     .build()
 
+@userExp.staticImplements
+class User extends userExp.extends implements Implements<typeof userExp> {}
 
-@exp.staticImplements
+const userInst = User.create({ id: Option.some(1n), name: "User" })
-class User extends exp.extends implements Implements<typeof exp> {}
+const userInstEffect = User.createEffect({ id: Option.some(1n), name: "User" })
-
-const inst = User.create({ id: 1n, name: "User" })
-// console.log(inst.name)
-const instEffect = User.createEffect({ id: 1n, name: "User" })
-
-const jsonifiedUser = await inst.jsonifyPromise()
-const dejsonifiedInst = await User.dejsonifyPromise(jsonifiedUser)
 
 
-// const AdminUserProto = User.extend()
+const jsonifiedUserExp = JsonifiedZodSchemaClass(User, {
-//     .schema({
+    jsonifySchema: schema => schema.extend({
-//         schema: s => s.extend({
+        id: s.effect.option.jsonify(schema.shape.id, s.bigint.jsonify)
-//             name: z.literal("Admin"),
+    }),
-//             prout: z.string(),
+
-//         }),
+    dejsonifySchema: schema => schema.extend({
-//         defaultValues: v => ({ ...v, name: "Admin" as const }),
+        id: s.effect.option.dejsonify(schema.shape.id, s.bigint.dejsonify)
-//     })
+    }),
-//     .jsonifiable({
+}).build()
-//         jsonifySchema: (s, json) => json.extend({
+
-//             prout: s.shape.prout
+@jsonifiedUserExp.staticImplements
-//         })
+class JsonifiedUser extends jsonifiedUserExp.extends implements Implements<typeof jsonifiedUserExp> {}
-//     })
+
+const jsonifiedUserInst = JsonifiedUser.jsonify(userInst)
+// console.log(JSON.stringify(jsonifiedUserInst))
+console.log(jsonifiedUserInst.dejsonify().id)
 
 
-// class AdminUser extends AdminUserProto.toClass() {}
+const adminUserExp = ExtendZodSchemaClass(User,
-// const subInst = await AdminUser.createPromise({ id: 2n, prout: "" })
+    schema => schema.extend({
-// console.log(subInst)
+        role: z.literal("Admin").default("Admin")
+    })
+).build()
+
+@adminUserExp.staticImplements
+class AdminUser extends adminUserExp.extends implements Implements<typeof adminUserExp> {}
+
+const admin = AdminUser.create({ id: Option.some(2n), name: "Admin" })

src/tests2.ts

@@ -0,0 +1,20 @@
+import { Option } from "effect"
+import { z } from "zod"
+import { s } from "./schema/lib"
+
+
+const schema = z.object({
+    id: s.effect.option(z.bigint())
+})
+
+const jsonifySchema = schema.extend({
+    id: s.effect.option.jsonify(schema.shape.id, s.bigint.jsonify)
+})
+
+const dejsonifySchema = schema.extend({
+    id: s.effect.option.dejsonify(schema.shape.id, s.bigint.dejsonify)
+})
+
+
+const jsonified = jsonifySchema.parse({ id: Option.some(1n) })
+console.log(dejsonifySchema.parse(jsonified))

src/traits/ExtendableZodSchemaObject.ts

@@ -1,16 +1,51 @@
-// import { trait } from "@thilawyn/traitify-ts"
+import { ImplStatic, expression, implStaticThis } from "@thilawyn/traitify-ts"
-// import { ZodSchemaClassExtender } from "../builders/ZodSchemaClassExtender"
+import { AbstractClass } from "type-fest"
-// import { ZodSchemaClass } from "../shapes/ZodSchemaClass"
+import { z } from "zod"
+import { Extend, StaticMembers } from "../util"
+import { ZodSchemaObject } from "./ZodSchemaObject"
 
 
-// export const ExtendableZodSchemaObject = trait
+export const ExtendableZodSchemaObject = <
-//     .implement(Super => class ExtendableZodSchemaObject extends Super {
+    T             extends z.ZodRawShape,
-//         static extend<
+    Catchall      extends z.ZodTypeAny,
-//             Self extends ZodSchemaClass<any, any, any, any, any, any, any, any, any>,
+    Values        extends object,
-//         >(
+    PartialValues extends Partial<Values>,
-//             this: Self
+>(
-//         ) {
+    schemaWithDefaults: z.ZodObject<T, "strip", Catchall, Values, PartialValues>,
-//             return new ZodSchemaClassExtender(this, this)
+) => expression
-//         }
+    .expresses(ZodSchemaObject(schemaWithDefaults))
-//     })
+    .build()
-//     .build()
+    .subtrait()
+        .implement(Super => class ExtendableZodSchemaObjectImpl extends Super {
+            static extend<
+                Self                  extends AbstractClass<Values, [values: Values]>,
+
+                ExtendedT             extends z.ZodRawShape,
+                ExtendedCatchall      extends z.ZodTypeAny,
+                ExtendedValues        extends Values,
+                ExtendedPartialValues extends Partial<ExtendedValues>,
+            >(
+                this: Self,
+
+                schemaWithDefaults: (
+                    schemaWithDefaults: z.ZodObject<T, "strip", Catchall, Values, PartialValues>
+                ) => z.ZodObject<ExtendedT, "strip", ExtendedCatchall, ExtendedValues, ExtendedPartialValues>,
+            ) {
+                const t = implStaticThis(ExtendableZodSchemaObjectImpl, this)
+                return expression
+                    .extends(
+                        t as unknown as (
+                            AbstractClass<
+                                Omit<
+                                    Extend<[InstanceType<Self>, ExtendedValues]>,
+                                    keyof ExtendableZodSchemaObjectImpl
+                                >,
+                                [values: ExtendedValues]
+                            > &
+                            Omit<StaticMembers<Self>, keyof ImplStatic<typeof ExtendableZodSchemaObjectImpl>>
+                        )
+                    )
+                    .expresses(ExtendableZodSchemaObject(schemaWithDefaults(t.schemaWithDefaults)))
+            }
+        })
+        .build()

src/traits/JsonifiableZodSchemaObject.ts

@@ -1,110 +0,0 @@
-import { ImplStatic, expression } from "@thilawyn/traitify-ts"
-import { Class } from "type-fest"
-import { JsonifiableObject } from "type-fest/source/jsonifiable"
-import { z } from "zod"
-import { parseZodSchemaEffect } from "../util"
-import { ZodSchemaObject } from "./ZodSchemaObject"
-
-
-export const JsonifiableZodSchemaObject = <
-    SchemaT                            extends z.ZodRawShape,
-    SchemaUnknownKeys                  extends z.UnknownKeysParam,
-    SchemaCatchall                     extends z.ZodTypeAny,
-
-    SchemaWithDefaultValuesT           extends z.ZodRawShape,
-    SchemaWithDefaultValuesUnknownKeys extends z.UnknownKeysParam,
-    SchemaWithDefaultValuesCatchall    extends z.ZodTypeAny,
-
-    Values                             extends object,
-    PartialValues                      extends Partial<Values>,
-
-    JsonifySchemaT                     extends z.ZodRawShape,
-    JsonifySchemaUnknownKeys           extends z.UnknownKeysParam,
-    JsonifySchemaCatchall              extends z.ZodTypeAny,
-
-    DejsonifySchemaT                   extends z.ZodRawShape,
-    DejsonifySchemaUnknownKeys         extends z.UnknownKeysParam,
-    DejsonifySchemaCatchall            extends z.ZodTypeAny,
-
-    JsonifiedValues                    extends JsonifiableObject,
->(
-    schema:                   z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>,
-    schemaWithDefaultValues:  z.ZodObject<SchemaWithDefaultValuesT, SchemaWithDefaultValuesUnknownKeys, SchemaWithDefaultValuesCatchall, Values, PartialValues>,
-    jsonifySchema:            z.ZodObject<JsonifySchemaT, JsonifySchemaUnknownKeys, JsonifySchemaCatchall, JsonifiedValues, Values>,
-    dejsonifySchema:          z.ZodObject<DejsonifySchemaT, DejsonifySchemaUnknownKeys, DejsonifySchemaCatchall, Values, JsonifiedValues>,
-) => expression
-    .expresses(ZodSchemaObject(schema, schemaWithDefaultValues))
-    .build()
-    .subtrait()
-        .implement(Super => class JsonifiableZodSchemaObject extends Super {
-            declare ["constructor"]: typeof JsonifiableZodSchemaObject
-
-            static readonly jsonifySchema   = jsonifySchema
-            static readonly dejsonifySchema = dejsonifySchema
-
-
-            jsonify(params?: Partial<z.ParseParams>) {
-                return this.constructor.jsonifySchema.parse(this, params)
-            }
-
-            jsonifyPromise(params?: Partial<z.ParseParams>) {
-                return this.constructor.jsonifySchema.parseAsync(this, params)
-            }
-
-            jsonifyEffect(params?: Partial<z.ParseParams>) {
-                return parseZodSchemaEffect(
-                    this.constructor.jsonifySchema,
-                    this,
-                    params,
-                )
-            }
-
-
-            static dejsonify<
-                Instance extends Values
-            >(
-                this: (
-                    Class<Instance, [values: Values]> &
-                    ImplStatic<typeof JsonifiableZodSchemaObject>
-                ),
-                values:   JsonifiedValues,
-                params?:  Partial<z.ParseParams>,
-            ) {
-                return this
-                    .transform(this.dejsonifySchema)
-                    .parse(values, params)
-            }
-
-            static dejsonifyPromise<
-                Instance extends Values
-            >(
-                this: (
-                    Class<Instance, [values: Values]> &
-                    ImplStatic<typeof JsonifiableZodSchemaObject>
-                ),
-                values:   JsonifiedValues,
-                params?:  Partial<z.ParseParams>,
-            ) {
-                return this
-                    .transform(this.dejsonifySchema)
-                    .parseAsync(values, params)
-            }
-
-            static dejsonifyEffect<
-                Instance extends Values
-            >(
-                this: (
-                    Class<Instance, [values: Values]> &
-                    ImplStatic<typeof JsonifiableZodSchemaObject>
-                ),
-                values:   JsonifiedValues,
-                params?:  Partial<z.ParseParams>,
-            ) {
-                return parseZodSchemaEffect(
-                    this.transform(this.dejsonifySchema),
-                    values,
-                    params,
-                )
-            }
-        })
-        .build()

src/traits/JsonifiedZodSchemaObject.ts

@@ -0,0 +1,174 @@
+import { TraitInstance, TraitStaticMembers, implStaticInstantiableThis, trait } from "@thilawyn/traitify-ts"
+import { Class, Jsonifiable } from "type-fest"
+import { z } from "zod"
+import { parseZodSchemaEffect } from "../util"
+import { ZodSchemaObjectTrait } from "./ZodSchemaObject"
+
+
+export type OfClass<
+    Instance      extends OfClassInstance<T, Catchall, Values, PartialValues>,
+
+    T             extends z.ZodRawShape,
+    Catchall      extends z.ZodTypeAny,
+    Values        extends object,
+    PartialValues extends Partial<Values>,
+> = (
+    Class<Instance, [values: Values]> &
+    TraitStaticMembers<ZodSchemaObjectTrait<T, Catchall, Values, PartialValues>>
+)
+
+export type OfClassInstance<
+    T                 extends z.ZodRawShape,
+    Catchall          extends z.ZodTypeAny,
+    Values            extends object,
+    PartialValues     extends Partial<Values>,
+> = (
+    Values & TraitInstance<ZodSchemaObjectTrait<T, Catchall, Values, PartialValues>>
+)
+
+
+export const JsonifiedZodSchemaObject = <
+    Of                extends OfClass<OfInstance, T, Catchall, Values, PartialValues>,
+    OfInstance        extends OfClassInstance<T, Catchall, Values, PartialValues>,
+    T                 extends z.ZodRawShape,
+    Catchall          extends z.ZodTypeAny,
+    Values            extends object,
+    PartialValues     extends Partial<Values>,
+
+    JsonifyT          extends z.ZodRawShape,
+    JsonifyCatchall   extends z.ZodTypeAny,
+    DejsonifyT        extends z.ZodRawShape,
+    DejsonifyCatchall extends z.ZodTypeAny,
+    JsonifiedValues   extends object & Jsonifiable,
+>(
+    of: Of | OfClass<OfInstance, T, Catchall, Values, PartialValues>,
+
+    props: {
+        jsonifySchema: (
+            schema: typeof of.schema
+        ) => z.ZodObject<JsonifyT, "strip", JsonifyCatchall, JsonifiedValues, Values>,
+
+        dejsonifySchema: (
+            schema: typeof of.schema
+        ) => z.ZodObject<DejsonifyT, "strip", DejsonifyCatchall, Values, JsonifiedValues>,
+    },
+) => trait
+    .implement(Super => class JsonifiedZodSchemaObjectImpl extends Super {
+        declare ["constructor"]: typeof JsonifiedZodSchemaObjectImpl
+
+        static readonly of              = of as Of
+        static readonly jsonifySchema   = props.jsonifySchema(of.schema)
+        static readonly dejsonifySchema = props.dejsonifySchema(of.schema)
+
+
+        static pipeSchemaIntoInstance<
+            Instance          extends JsonifiedValues,
+
+            SchemaT           extends z.ZodRawShape,
+            SchemaUnknownKeys extends z.UnknownKeysParam,
+            SchemaCatchall    extends z.ZodTypeAny,
+            SchemaOutput      extends JsonifiedValues,
+            SchemaInput,
+        >(
+            this:    Class<Instance, [values: JsonifiedValues]>,
+            schema:  z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, SchemaOutput, SchemaInput>,
+        ) {
+            return schema.transform(values => new this(values))
+        }
+
+
+        static jsonify<
+            Instance extends JsonifiedValues
+        >(
+            this:     Class<Instance, [values: JsonifiedValues]>,
+            values:   Values,
+            params?:  Partial<z.ParseParams>,
+        ) {
+            const t = implStaticInstantiableThis(JsonifiedZodSchemaObjectImpl, this)
+
+            return t
+                .pipeSchemaIntoInstance(t.jsonifySchema)
+                .parse(values, params)
+        }
+
+        static jsonifyPromise<
+            Instance extends JsonifiedValues
+        >(
+            this:     Class<Instance, [values: JsonifiedValues]>,
+            values:   Values,
+            params?:  Partial<z.ParseParams>,
+        ) {
+            const t = implStaticInstantiableThis(JsonifiedZodSchemaObjectImpl, this)
+
+            return t
+                .pipeSchemaIntoInstance(t.jsonifySchema)
+                .parseAsync(values, params)
+        }
+
+        static jsonifyEffect<
+            Instance extends JsonifiedValues
+        >(
+            this:     Class<Instance, [values: JsonifiedValues]>,
+            values:   Values,
+            params?:  Partial<z.ParseParams>,
+        ) {
+            const t = implStaticInstantiableThis(JsonifiedZodSchemaObjectImpl, this)
+
+            return parseZodSchemaEffect(
+                t.pipeSchemaIntoInstance(t.jsonifySchema),
+                values,
+                params,
+            )
+        }
+
+
+        static dejsonify(
+            values:   JsonifiedValues,
+            params?:  Partial<z.ParseParams>,
+        ) {
+            return this.of
+                .pipeSchemaIntoInstance(this.dejsonifySchema)
+                .parse(values, params)
+        }
+
+        static dejsonifyPromise(
+            values:   JsonifiedValues,
+            params?:  Partial<z.ParseParams>,
+        ) {
+            return this.of
+                .pipeSchemaIntoInstance(this.dejsonifySchema)
+                .parseAsync(values, params)
+        }
+
+        static dejsonifyEffect(
+            values:   JsonifiedValues,
+            params?:  Partial<z.ParseParams>,
+        ) {
+            return parseZodSchemaEffect(
+                this.of.pipeSchemaIntoInstance(this.dejsonifySchema),
+                values,
+                params,
+            )
+        }
+
+        dejsonify(params?: Partial<z.ParseParams>) {
+            return this.constructor.of.pipeSchemaIntoInstance(
+                this.constructor.dejsonifySchema
+            ).parse(this, params)
+        }
+
+        dejsonifyPromise(params?: Partial<z.ParseParams>) {
+            return this.constructor.of.pipeSchemaIntoInstance(
+                this.constructor.dejsonifySchema
+            ).parseAsync(this, params)
+        }
+
+        dejsonifyEffect(params?: Partial<z.ParseParams>) {
+            return parseZodSchemaEffect(
+                this.constructor.of.pipeSchemaIntoInstance(this.constructor.dejsonifySchema),
+                this,
+                params,
+            )
+        }
+    })
+    .build()

src/traits/MobXObservableZodSchemaObject.ts

@@ -8,13 +8,15 @@ export const MobXObservableZodSchemaObject = trait
     .staticAbstract(Super => class extends Super {
         declare readonly schema: z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny, object, object>
     })
-    .implement(Super => class ObservableZodSchemaObject extends Super {
+    .implement(Super => class MobXObservableZodSchemaObjectImpl extends Super {
+        declare ["constructor"]: typeof MobXObservableZodSchemaObjectImpl
+
         constructor(...args: any[]) {
             super(...args)
 
             makeObservable(this,
                 mapValues(
-                    (this.constructor as typeof ObservableZodSchemaObject).schema.shape,
+                    this.constructor.schema.shape,
                     () => observable,
                 )
             )

src/traits/ZodSchemaObject.ts

@@ -1,7 +1,7 @@
-import { ImplStatic, trait } from "@thilawyn/traitify-ts"
+import { implStaticInstantiableThis, trait } from "@thilawyn/traitify-ts"
 import { Class, HasRequiredKeys } from "type-fest"
 import { z } from "zod"
-import { parseZodSchemaEffect } from "../util"
+import { parseZodSchemaEffect, stripZodObjectDefaults } from "../util"
 
 
 type CreateArgs<Input extends object> = (
@@ -12,111 +12,104 @@ type CreateArgs<Input extends object> = (
 
 
 export const ZodSchemaObject = <
-    SchemaT                            extends z.ZodRawShape,
+    T             extends z.ZodRawShape,
-    SchemaUnknownKeys                  extends z.UnknownKeysParam,
+    Catchall      extends z.ZodTypeAny,
-    SchemaCatchall                     extends z.ZodTypeAny,
+    Values        extends object,
-
+    PartialValues extends Partial<Values>,
-    SchemaWithDefaultValuesT           extends z.ZodRawShape,
-    SchemaWithDefaultValuesUnknownKeys extends z.UnknownKeysParam,
-    SchemaWithDefaultValuesCatchall    extends z.ZodTypeAny,
-
-    Values                             extends object,
-    PartialValues                      extends Partial<Values>,
 >(
-    schema:                   z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, Values, Values>,
+    schemaWithDefaults: z.ZodObject<T, "strip", Catchall, Values, PartialValues>,
-    schemaWithDefaultValues:  z.ZodObject<SchemaWithDefaultValuesT, SchemaWithDefaultValuesUnknownKeys, SchemaWithDefaultValuesCatchall, Values, PartialValues>,
 ) => trait
-    .implement(Super => class ZodSchemaObject extends Super {
+    .implement(Super => {
-        static readonly schema                  = schema
+        class ZodSchemaObjectImpl extends Super {
-        static readonly schemaWithDefaultValues = schemaWithDefaultValues
+            static readonly schema             = stripZodObjectDefaults(schemaWithDefaults)
+            static readonly schemaWithDefaults = schemaWithDefaults
 
-        static transform<
-            Instance    extends Values,
 
-            T           extends z.ZodRawShape,
+            static pipeSchemaIntoInstance<
-            UnknownKeys extends z.UnknownKeysParam,
+                Instance          extends Values,
-            Catchall    extends z.ZodTypeAny,
+
-            Output      extends Values,
+                SchemaT           extends z.ZodRawShape,
-            Input,
+                SchemaUnknownKeys extends z.UnknownKeysParam,
-        >(
+                SchemaCatchall    extends z.ZodTypeAny,
-            this:    Class<Instance, [values: Values]>,
+                SchemaOutput      extends Values,
-            schema:  z.ZodObject<T, UnknownKeys, Catchall, Output, Input>,
+                SchemaInput,
-        ) {
+            >(
-            return schema.transform(values => new this(values))
+                this:    Class<Instance, [values: Values]>,
+                schema:  z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, SchemaOutput, SchemaInput>,
+            ) {
+                return schema.transform(values => new this(values))
+            }
+
+            static pipeInstanceIntoSchema<
+                Self              extends Class<Values, [values: Values]>,
+
+                SchemaT           extends z.ZodRawShape,
+                SchemaUnknownKeys extends z.UnknownKeysParam,
+                SchemaCatchall    extends z.ZodTypeAny,
+                SchemaOutput,
+                SchemaInput       extends Values,
+            >(
+                this:    Self,
+                schema:  z.ZodObject<SchemaT, SchemaUnknownKeys, SchemaCatchall, SchemaOutput, SchemaInput>,
+            ) {
+                return z.instanceof(this).pipe(schema)
+            }
+
+
+            static create<
+                Instance extends Values
+            >(
+                this: Class<Instance, [values: Values]>,
+                ...[values, params]: CreateArgs<PartialValues>
+            ) {
+                const t = implStaticInstantiableThis(ZodSchemaObjectImpl, this)
+
+                return t
+                    .pipeSchemaIntoInstance(t.schemaWithDefaults)
+                    .parse(values, params)
+            }
+
+            static createPromise<
+                Instance extends Values
+            >(
+                this: Class<Instance, [values: Values]>,
+                ...[values, params]: CreateArgs<PartialValues>
+            ) {
+                const t = implStaticInstantiableThis(ZodSchemaObjectImpl, this)
+
+                return t
+                    .pipeSchemaIntoInstance(t.schemaWithDefaults)
+                    .parseAsync(values, params)
+            }
+
+            static createEffect<
+                Instance extends Values
+            >(
+                this: Class<Instance, [values: Values]>,
+                ...[values, params]: CreateArgs<PartialValues>
+            ) {
+                const t = implStaticInstantiableThis(ZodSchemaObjectImpl, this)
+
+                return parseZodSchemaEffect(
+                    t.pipeSchemaIntoInstance(t.schemaWithDefaults),
+                    values,
+                    params,
+                )
+            }
         }
 
-
+        return ZodSchemaObjectImpl
-        static create<
-            Instance extends Values
-        >(
-            this: (
-                Class<Instance, [values: Values]> &
-                ImplStatic<typeof ZodSchemaObject>
-            ),
-            ...[values, params]: CreateArgs<PartialValues>
-        ) {
-            return this
-                .transform(this.schemaWithDefaultValues)
-                .parse(values, params)
-        }
-
-        static createPromise<
-            Instance extends Values
-        >(
-            this: (
-                Class<Instance, [values: Values]> &
-                ImplStatic<typeof ZodSchemaObject>
-            ),
-            ...[values, params]: CreateArgs<PartialValues>
-        ) {
-            return this
-                .transform(this.schemaWithDefaultValues)
-                .parseAsync(values, params)
-        }
-
-        static createEffect<
-            Instance extends Values
-        >(
-            this: (
-                Class<Instance, [values: Values]> &
-                ImplStatic<typeof ZodSchemaObject>
-            ),
-            ...[values, params]: CreateArgs<PartialValues>
-        ) {
-            return parseZodSchemaEffect(
-                this.transform(this.schemaWithDefaultValues),
-                values,
-                params,
-            )
-        }
     })
     .build()
 
 
 export type ZodSchemaObjectTrait<
-    SchemaT                            extends z.ZodRawShape,
+    T             extends z.ZodRawShape,
-    SchemaUnknownKeys                  extends z.UnknownKeysParam,
+    Catchall      extends z.ZodTypeAny,
-    SchemaCatchall                     extends z.ZodTypeAny,
+    Values        extends object,
-
+    PartialValues extends Partial<Values>,
-    SchemaWithDefaultValuesT           extends z.ZodRawShape,
-    SchemaWithDefaultValuesUnknownKeys extends z.UnknownKeysParam,
-    SchemaWithDefaultValuesCatchall    extends z.ZodTypeAny,
-
-    Values                             extends object,
-    PartialValues                      extends Partial<Values>,
 > = (
     ReturnType<
-        typeof ZodSchemaObject<
+        typeof ZodSchemaObject<T, Catchall, Values, PartialValues>
-            SchemaT,
-            SchemaUnknownKeys,
-            SchemaCatchall,
-
-            SchemaWithDefaultValuesT,
-            SchemaWithDefaultValuesUnknownKeys,
-            SchemaWithDefaultValuesCatchall,
-
-            Values,
-            PartialValues
-        >
     >
 )

src/util/class.ts

@@ -1,69 +1,6 @@
-import { AbstractClass, Class as ConcreteClass } from "type-fest"
+import { AbstractClass } from "type-fest"
 
 
-/**
- * Represents the possible types of a class.
- */
-export type ClassType = "AbstractClass" | "Class"
-
-/**
- * Represents a class based on the specified type.
- * @template Type - The type of the class ("AbstractClass" or "Class").
- * @template T - The type parameter of the class.
- * @template Arguments - The type of arguments the class constructor takes.
- */
-export type Class<
-    Type extends ClassType,
-    T,
-    Arguments extends unknown[] = any[],
-> = (
-    Type extends "AbstractClass"
-        ? AbstractClass<T, Arguments>
-        : Type extends "Class"
-            ? ConcreteClass<T, Arguments>
-            : never
-)
-
-/**
- * Gets the type of a class (either "Class" or "AbstractClass").
- * @template C - The class type to determine.
- */
-export type GetClassType<C> = (
-    C extends ConcreteClass<any>
-        ? "Class"
-        : C extends AbstractClass<any>
-            ? "AbstractClass"
-            : never
-)
-
-/**
- * Represents an array of instances corresponding to the provided classes.
- * @template Classes - An array of classes extending AbstractClass.
- */
-export type ClassesInstances<Classes extends readonly AbstractClass<any>[]> = (
-    Classes extends [infer Class, ...infer Rest]
-        ? Class extends AbstractClass<any>
-            ? Rest extends AbstractClass<any>[]
-                ? [InstanceType<Class>, ...ClassesInstances<Rest>]
-                : never
-            : never
-        : []
-)
-
-/**
- * Represents an intersection of instances of the provided classes.
- * @template Classes - An array of classes extending AbstractClass.
- */
-export type ClassesInstancesIntersection<Classes extends readonly AbstractClass<any>[]> = (
-    Classes extends [infer Class, ...infer Rest]
-        ? Class extends AbstractClass<any>
-            ? Rest extends AbstractClass<any>[]
-                ? InstanceType<Class> & ClassesInstancesIntersection<Rest>
-                : never
-            : never
-        : {}
-)
-
 /**
  * Represents the static members of a class.
  * @template Class - A class extending AbstractClass.
@@ -71,31 +8,3 @@ export type ClassesInstancesIntersection<Classes extends readonly AbstractClass<
 export type StaticMembers<Class extends AbstractClass<any>> = (
     Omit<Class, "prototype">
 )
-
-/**
- * Represents an array of static members corresponding to the provided classes.
- * @template Classes - An array of classes extending AbstractClass.
- */
-export type ClassesStaticMembers<Classes extends readonly AbstractClass<any>[]> = (
-    Classes extends [infer Class, ...infer Rest]
-        ? Class extends AbstractClass<any>
-            ? Rest extends AbstractClass<any>[]
-                ? [StaticMembers<Class>, ...ClassesStaticMembers<Rest>]
-                : never
-            : never
-        : []
-)
-
-/**
- * Represents an intersection of static members of the provided classes.
- * @template Classes - An array of classes extending AbstractClass.
- */
-export type ClassesStaticMembersIntersection<Classes extends readonly AbstractClass<any>[]> = (
-    Classes extends [infer Class, ...infer Rest]
-        ? Class extends AbstractClass<any>
-            ? Rest extends AbstractClass<any>[]
-                ? StaticMembers<Class> & ClassesStaticMembersIntersection<Rest>
-                : never
-            : never
-        : {}
-)

src/util/index.ts

@@ -1,4 +1,4 @@
 export * from "./class"
 export * from "./effect"
 export * from "./extend"
-export * from "./misc"
+export * from "./zod"

src/util/misc.ts

@@ -1,3 +0,0 @@
-export function identity<T>(value: T) {
-    return value
-}

src/util/zod.ts

@@ -0,0 +1,25 @@
+import { mapValues } from "lodash-es"
+import { z } from "zod"
+
+
+export function stripZodObjectDefaults<
+    T           extends z.ZodRawShape,
+    UnknownKeys extends z.UnknownKeysParam,
+    Catchall    extends z.ZodTypeAny,
+    Output,
+    Input,
+>(
+    schema: z.ZodObject<T, UnknownKeys, Catchall, Output, Input>
+) {
+    return schema.extend(
+        mapValues(schema.shape, v =>
+            v instanceof z.ZodDefault
+                ? v.removeDefault()
+                : v
+        ) as {
+            [K in keyof T]: T[K] extends z.ZodDefault<z.ZodTypeAny>
+                ? ReturnType<T[K]["removeDefault"]>
+                : T[K]
+        }
+    )
+}

tsconfig.json

@@ -8,7 +8,7 @@
     // "allowImportingTsExtensions": true,
     // "noEmit": true,
     "declaration": true,
-    "composite": true,
+    // "composite": true,
     "strict": true,
     "downlevelIteration": true,
     "skipLibCheck": true,

tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "tsup"
+
+
+export default defineConfig({
+    entry: ["src/lib.ts", "src/schema/lib.ts"],
+    format: ["esm", "cjs"],
+    dts: true,
+    splitting: false,
+    sourcemap: true,
+    clean: true,
+})