typia 5.1.4 → 5.1.5

package/src/programmers/CheckerProgrammer.ts

@@ -67,22 +67,24 @@ export namespace CheckerProgrammer {
                 entries: IExpressionEntry[],
             ): ts.Expression;
             array(input: ts.Expression, arrow: ts.ArrowFunction): ts.Expression;
-            tuple?(exprs: ts.Expression[]): ts.Expression;
+            tuple?: undefined | ((exprs: ts.Expression[]) => ts.Expression);
 
             failure(
                 value: ts.Expression,
                 expected: string,
-                explore?: FeatureProgrammer.IExplore,
+                explore?: undefined | FeatureProgrammer.IExplore,
             ): ts.Expression;
             is?(expression: ts.Expression): ts.Expression;
             required?(exp: ts.Expression): ts.Expression;
-            full?: (
-                condition: ts.Expression,
-            ) => (
-                input: ts.Expression,
-                expected: string,
-                explore: IExplore,
-            ) => ts.Expression;
+            full?:
+                | undefined
+                | ((
+                      condition: ts.Expression,
+                  ) => (
+                      input: ts.Expression,
+                      expected: string,
+                      explore: IExplore,
+                  ) => ts.Expression);
         }
     }
     export type IExplore = FeatureProgrammer.IExplore;

package/src/programmers/FeatureProgrammer.ts

@@ -40,7 +40,9 @@ export namespace FeatureProgrammer {
          */
         trace: boolean;
 
-        addition?(collection: MetadataCollection): ts.Statement[];
+        addition?:
+            | undefined
+            | ((collection: MetadataCollection) => ts.Statement[]);
 
         /**
          * Initializer of metadata.
@@ -68,8 +70,8 @@ export namespace FeatureProgrammer {
     }
     export namespace IConfig {
         export interface ITypes {
-            input: (type: ts.Type, name?: string) => ts.TypeNode;
-            output: (type: ts.Type, name?: string) => ts.TypeNode;
+            input: (type: ts.Type, name?: undefined | string) => ts.TypeNode;
+            output: (type: ts.Type, name?: undefined | string) => ts.TypeNode;
         }
 
         export interface IObjector<
@@ -113,7 +115,7 @@ export namespace FeatureProgrammer {
             failure(
                 value: ts.Expression,
                 expected: string,
-                explore?: IExplore,
+                explore?: undefined | IExplore,
             ): ts.Statement;
 
             /**
@@ -129,7 +131,7 @@ export namespace FeatureProgrammer {
              * @returns Transformed expression
              * @deprecated
              */
-            is?(exp: ts.Expression): ts.Expression;
+            is?: undefined | ((exp: ts.Expression) => ts.Expression);
 
             /**
              * Transformer of non-undefined type checking by discrimination.
@@ -146,7 +148,7 @@ export namespace FeatureProgrammer {
              * @returns Transformed expression
              * @deprecated
              */
-            required?(exp: ts.Expression): ts.Expression;
+            required?: undefined | ((exp: ts.Expression) => ts.Expression);
 
             /**
              * Conditon wrapper when unable to specify any object type.
@@ -158,22 +160,28 @@ export namespace FeatureProgrammer {
              * @param condition Current condition
              * @returns A function wrapped current condition
              */
-            full?: (
-                condition: ts.Expression,
-            ) => (
-                input: ts.Expression,
-                expected: string,
-                explore: IExplore,
-            ) => ts.Expression;
+            full?:
+                | undefined
+                | ((
+                      condition: ts.Expression,
+                  ) => (
+                      input: ts.Expression,
+                      expected: string,
+                      explore: IExplore,
+                  ) => ts.Expression);
 
             /**
              * Return type.
              */
-            type?: ts.TypeNode;
+            type?: undefined | ts.TypeNode;
         }
         export interface IGenerator {
-            objects?(): (col: MetadataCollection) => ts.VariableStatement[];
-            unions?(): (col: MetadataCollection) => ts.VariableStatement[];
+            objects?:
+                | undefined
+                | (() => (col: MetadataCollection) => ts.VariableStatement[]);
+            unions?:
+                | undefined
+                | (() => (col: MetadataCollection) => ts.VariableStatement[]);
             arrays(): (col: MetadataCollection) => ts.VariableStatement[];
             tuples(): (col: MetadataCollection) => ts.VariableStatement[];
         }
@@ -184,7 +192,7 @@ export namespace FeatureProgrammer {
         source: "top" | "function";
         from: "top" | "array" | "object";
         postfix: string;
-        start?: number;
+        start?: undefined | number;
     }
 
     export interface Decoder<

package/src/programmers/helpers/HttpMetadataUtil.ts

@@ -1,21 +1,21 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-export namespace HttpMetadataUtil {
-    export const atomics = (
-        meta: Metadata,
-    ): Set<"boolean" | "bigint" | "number" | "string"> =>
-        new Set([
-            ...meta.atomics.map((a) => a.type),
-            ...meta.constants.map((c) => c.type),
-            ...(meta.templates.length ? (["string"] as const) : []),
-        ]);
-
-    export const isUnion = (meta: Metadata): boolean =>
-        atomics(meta).size +
-            meta.arrays.length +
-            meta.tuples.length +
-            meta.natives.length +
-            meta.maps.length +
-            meta.objects.length >
-        1;
-}
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+export namespace HttpMetadataUtil {
+    export const atomics = (
+        meta: Metadata,
+    ): Set<"boolean" | "bigint" | "number" | "string"> =>
+        new Set([
+            ...meta.atomics.map((a) => a.type),
+            ...meta.constants.map((c) => c.type),
+            ...(meta.templates.length ? (["string"] as const) : []),
+        ]);
+
+    export const isUnion = (meta: Metadata): boolean =>
+        atomics(meta).size +
+            meta.arrays.length +
+            meta.tuples.length +
+            meta.natives.length +
+            meta.maps.length +
+            meta.objects.length >
+        1;
+}

package/src/programmers/helpers/RandomRanger.ts

@@ -168,6 +168,6 @@ interface IRange {
     maximum: IScalar;
 }
 interface IScalar {
-    value?: number;
+    value?: undefined | number;
     exclusive: boolean;
 }

package/src/programmers/http/HttpAssertHeadersProgrammer.ts

@@ -1,77 +1,77 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
-
-export namespace HttpAssertHeadersProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string): ts.ArrowFunction =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        ts.factory.createTypeReferenceNode(
-                            HttpHeadersProgrammer.INPUT_TYPE,
-                        ),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode(
-                    `typia.Resolved<${
-                        name ?? TypeFactory.getFullName(project.checker)(type)
-                    }>`,
-                ),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "decode",
-                        HttpHeadersProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "assert",
-                        AssertProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("decode"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createAsExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("assert"),
-                                undefined,
-                                [ts.factory.createIdentifier("output")],
-                            ),
-                            TypeFactory.keyword("any"),
-                        ),
-                    ),
-                ]),
-            );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
+
+export namespace HttpAssertHeadersProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string): ts.ArrowFunction =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        ts.factory.createTypeReferenceNode(
+                            HttpHeadersProgrammer.INPUT_TYPE,
+                        ),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode(
+                    `typia.Resolved<${
+                        name ?? TypeFactory.getFullName(project.checker)(type)
+                    }>`,
+                ),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "decode",
+                        HttpHeadersProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "assert",
+                        AssertProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("decode"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("assert"),
+                                undefined,
+                                [ts.factory.createIdentifier("output")],
+                            ),
+                            TypeFactory.keyword("any"),
+                        ),
+                    ),
+                ]),
+            );
+}

package/src/programmers/http/HttpAssertQueryProgrammer.ts

@@ -1,77 +1,77 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { HttpQueryProgrammer } from "./HttpQueryProgrammer";
-
-export namespace HttpAssertQueryProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string): ts.ArrowFunction =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        ts.factory.createTypeReferenceNode(
-                            HttpQueryProgrammer.INPUT_TYPE,
-                        ),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode(
-                    `typia.Resolved<${
-                        name ?? TypeFactory.getFullName(project.checker)(type)
-                    }>`,
-                ),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "decode",
-                        HttpQueryProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "assert",
-                        AssertProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("decode"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createAsExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("assert"),
-                                undefined,
-                                [ts.factory.createIdentifier("output")],
-                            ),
-                            TypeFactory.keyword("any"),
-                        ),
-                    ),
-                ]),
-            );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { HttpQueryProgrammer } from "./HttpQueryProgrammer";
+
+export namespace HttpAssertQueryProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string): ts.ArrowFunction =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        ts.factory.createTypeReferenceNode(
+                            HttpQueryProgrammer.INPUT_TYPE,
+                        ),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode(
+                    `typia.Resolved<${
+                        name ?? TypeFactory.getFullName(project.checker)(type)
+                    }>`,
+                ),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "decode",
+                        HttpQueryProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "assert",
+                        AssertProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("decode"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("assert"),
+                                undefined,
+                                [ts.factory.createIdentifier("output")],
+                            ),
+                            TypeFactory.keyword("any"),
+                        ),
+                    ),
+                ]),
+            );
+}