Option refactoring

src/schema/effect/option.ts

@@ -6,75 +6,91 @@ import { z } from "zod"
 type JsonifiedEffectOptionSomeBrand = "@thilawyn/zod-schema-class/JsonifiedEffectOptionSome"
 
 
-export const option = <S extends z.ZodTypeAny>(schema: S) =>
+export function option<S extends z.ZodTypeAny>(schema: S) {
-    z.union([option.some(schema), option.none(schema)])
+    return z.union([option.some(schema), option.none(schema)])
+}
 
-
+export module option {
-const some = <
+    export function some<
         InnerS extends z.ZodTypeAny
->(schema: InnerS) => z
+    >(
+        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<Option.Some<z.output<InnerS>>>(identity)
+    }
 
-some.jsonify = <
+    export module some {
+        export function jsonify<
             InnerS          extends z.ZodTypeAny,
             JsonifiedInnerS extends z.ZodTypeAny = InnerS,
->(
+        >(
             schema:         ZodEffectOptionSome<InnerS>,
             jsonifySchema:  (schema: InnerS) => JsonifiedInnerS = identity,
-) => schema
+        ) {
+            return schema
                 .transform(v => Option.getOrThrow(v))
                 .pipe(jsonifySchema(effectOptionSomeInnerSchema(schema)))
                 .brand<JsonifiedEffectOptionSomeBrand>()
+        }
 
-some.dejsonify = <
+        export function dejsonify<
             InnerS            extends z.ZodTypeAny,
             DejsonifiedInnerS extends z.ZodTypeAny = InnerS,
->(
+        >(
             schema:           ZodEffectOptionSome<InnerS>,
             dejsonifySchema:  (schema: InnerS) => DejsonifiedInnerS = identity,
-) => z
+        ) {
+            return z
                 .custom<z.input<DejsonifiedInnerS> & z.BRAND<JsonifiedEffectOptionSomeBrand>>()
                 .pipe(dejsonifySchema(effectOptionSomeInnerSchema(schema)))
                 .transform(v => Option.some<z.output<DejsonifiedInnerS>>(v))
                 .pipe(schema)
-
+        }
-option.some = some
+    }
 
 
-const none = <
+    export function none<
         InnerS extends z.ZodTypeAny | unknown = unknown
->(_schema?: InnerS) =>
+    >(
-    z.custom<
+        _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")
+    }
 
-none.jsonify = <
+    export module none {
+        export function jsonify<
             InnerS          extends z.ZodTypeAny,
             JsonifiedInnerS extends z.ZodTypeAny = InnerS,
->(
+        >(
             schema:           ZodEffectOptionNone<InnerS>,
             _jsonifySchema?:  (schema: InnerS) => JsonifiedInnerS,
-) =>
+        ) {
-    schema.transform(() => null),
+            return schema.transform(() => null)
+        }
 
-none.dejsonify = <
+        export function dejsonify<
             InnerS            extends z.ZodTypeAny,
             DejsonifiedInnerS extends z.ZodTypeAny = InnerS,
->(
+        >(
             schema:             ZodEffectOptionNone<InnerS>,
             _dejsonifySchema?:  (schema: InnerS) => DejsonifiedInnerS,
-) => z
+        ) {
+            return z
                 .null()
                 .transform(() => Option.none<z.output<DejsonifiedInnerS>>())
-    .pipe(schema),
+                .pipe(schema)
-
+        }
-option.none = none
+    }
+}
 
 
 export type ZodEffectOption<S extends z.ZodTypeAny>     = ReturnType<typeof option<S>>