typia 7.0.0-dev.20241007 → 7.0.0-dev.20241008

package/src/programmers/misc/MiscValidateCloneProgrammer.ts

@@ -1,109 +1,111 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProgrammerProps } from "../../transformers/IProgrammerProps";
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
-import { MiscCloneProgrammer } from "./MiscCloneProgrammer";
-
-export namespace MiscValidateCloneProgrammer {
-  export const decompose = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const validate = ValidateProgrammer.decompose({
-      ...props,
-      config: {
-        equals: false,
-      },
-    });
-    const clone = MiscCloneProgrammer.decompose({
-      ...props,
-      validated: true,
-    });
-    return {
-      functions: {
-        ...validate.functions,
-        ...clone.functions,
-      },
-      statements: [
-        ...validate.statements,
-        ...clone.statements,
-        StatementFactory.constant({
-          name: "__validate",
-          value: validate.arrow,
-        }),
-        StatementFactory.constant({
-          name: "__clone",
-          value: clone.arrow,
-        }),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createTypeReferenceNode("typia.IValidation", [
-          clone.arrow.type ?? TypeFactory.keyword("any"),
-        ]),
-        undefined,
-        ts.factory.createBlock(
-          [
-            StatementFactory.constant({
-              name: "result",
-              value: ts.factory.createAsExpression(
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("__validate"),
-                  undefined,
-                  [ts.factory.createIdentifier("input")],
-                ),
-                TypeFactory.keyword("any"),
-              ),
-            }),
-            ts.factory.createIfStatement(
-              ts.factory.createIdentifier("result.success"),
-              ts.factory.createExpressionStatement(
-                ts.factory.createBinaryExpression(
-                  ts.factory.createIdentifier("result.data"),
-                  ts.SyntaxKind.EqualsToken,
-                  ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("__clone"),
-                    undefined,
-                    [ts.factory.createIdentifier("input")],
-                  ),
-                ),
-              ),
-            ),
-            ts.factory.createReturnStatement(
-              ts.factory.createIdentifier("result"),
-            ),
-          ],
-          true,
-        ),
-      ),
-    };
-  };
-
-  export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const functor: FunctionProgrammer = new FunctionProgrammer(
-      props.modulo.getText(),
-    );
-    const result: FeatureProgrammer.IDecomposed = decompose({
-      ...props,
-      functor,
-    });
-    return FeatureProgrammer.writeDecomposed({
-      modulo: props.modulo,
-      functor,
-      result,
-    });
-  };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+import { MiscCloneProgrammer } from "./MiscCloneProgrammer";
+
+export namespace MiscValidateCloneProgrammer {
+  export const decompose = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const validate = ValidateProgrammer.decompose({
+      ...props,
+      config: {
+        equals: false,
+      },
+    });
+    const clone = MiscCloneProgrammer.decompose({
+      ...props,
+      validated: true,
+    });
+    return {
+      functions: {
+        ...validate.functions,
+        ...clone.functions,
+      },
+      statements: [
+        ...validate.statements,
+        ...clone.statements,
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__clone",
+          value: clone.arrow,
+        }),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        props.context.importer.type({
+          file: "typia",
+          name: "IValidation",
+          arguments: [clone.arrow.type ?? TypeFactory.keyword("any")],
+        }),
+        undefined,
+        ts.factory.createBlock(
+          [
+            StatementFactory.constant({
+              name: "result",
+              value: ts.factory.createAsExpression(
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier("__validate"),
+                  undefined,
+                  [ts.factory.createIdentifier("input")],
+                ),
+                TypeFactory.keyword("any"),
+              ),
+            }),
+            ts.factory.createIfStatement(
+              ts.factory.createIdentifier("result.success"),
+              ts.factory.createExpressionStatement(
+                ts.factory.createBinaryExpression(
+                  ts.factory.createIdentifier("result.data"),
+                  ts.SyntaxKind.EqualsToken,
+                  ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("__clone"),
+                    undefined,
+                    [ts.factory.createIdentifier("input")],
+                  ),
+                ),
+              ),
+            ),
+            ts.factory.createReturnStatement(
+              ts.factory.createIdentifier("result"),
+            ),
+          ],
+          true,
+        ),
+      ),
+    };
+  };
+
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      functor,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      functor,
+      result,
+    });
+  };
+}

package/src/programmers/misc/MiscValidatePruneProgrammer.ts

@@ -1,109 +1,113 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProgrammerProps } from "../../transformers/IProgrammerProps";
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
-import { MiscPruneProgrammer } from "./MiscPruneProgrammer";
-
-export namespace MiscValidatePruneProgrammer {
-  export const decompose = (props: {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const validate: FeatureProgrammer.IDecomposed =
-      ValidateProgrammer.decompose({
-        ...props,
-        config: {
-          equals: false,
-        },
-      });
-    const prune: FeatureProgrammer.IDecomposed = MiscPruneProgrammer.decompose({
-      ...props,
-      validated: true,
-    });
-    return {
-      functions: {
-        ...validate.functions,
-        ...prune.functions,
-      },
-      statements: [
-        ...validate.statements,
-        ...prune.statements,
-        StatementFactory.constant({
-          name: "__validate",
-          value: validate.arrow,
-        }),
-        StatementFactory.constant({
-          name: "__prune",
-          value: prune.arrow,
-        }),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createTypeReferenceNode(
-          `typia.IValidation<${
-            props.name ??
-            TypeFactory.getFullName({
-              checker: props.context.checker,
-              type: props.type,
-            })
-          }>`,
-        ),
-        undefined,
-        ts.factory.createBlock(
-          [
-            StatementFactory.constant({
-              name: "result",
-              value: ts.factory.createCallExpression(
-                ts.factory.createIdentifier("__validate"),
-                undefined,
-                [ts.factory.createIdentifier("input")],
-              ),
-            }),
-            ts.factory.createIfStatement(
-              ts.factory.createIdentifier("result.success"),
-              ts.factory.createExpressionStatement(
-                ts.factory.createCallExpression(
-                  ts.factory.createIdentifier("__prune"),
-                  undefined,
-                  [ts.factory.createIdentifier("input")],
-                ),
-              ),
-            ),
-            ts.factory.createReturnStatement(
-              ts.factory.createIdentifier("result"),
-            ),
-          ],
-          true,
-        ),
-      ),
-    };
-  };
-
-  export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const functor: FunctionProgrammer = new FunctionProgrammer(
-      props.modulo.getText(),
-    );
-    const result: FeatureProgrammer.IDecomposed = decompose({
-      ...props,
-      functor,
-    });
-    return FeatureProgrammer.writeDecomposed({
-      modulo: props.modulo,
-      functor,
-      result,
-    });
-  };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+import { MiscPruneProgrammer } from "./MiscPruneProgrammer";
+
+export namespace MiscValidatePruneProgrammer {
+  export const decompose = (props: {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const validate: FeatureProgrammer.IDecomposed =
+      ValidateProgrammer.decompose({
+        ...props,
+        config: {
+          equals: false,
+        },
+      });
+    const prune: FeatureProgrammer.IDecomposed = MiscPruneProgrammer.decompose({
+      ...props,
+      validated: true,
+    });
+    return {
+      functions: {
+        ...validate.functions,
+        ...prune.functions,
+      },
+      statements: [
+        ...validate.statements,
+        ...prune.statements,
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__prune",
+          value: prune.arrow,
+        }),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
+        props.context.importer.type({
+          file: "typia",
+          name: "IValidation",
+          arguments: [
+            ts.factory.createTypeReferenceNode(
+              props.name ??
+                TypeFactory.getFullName({
+                  checker: props.context.checker,
+                  type: props.type,
+                }),
+            ),
+          ],
+        }),
+        undefined,
+        ts.factory.createBlock(
+          [
+            StatementFactory.constant({
+              name: "result",
+              value: ts.factory.createCallExpression(
+                ts.factory.createIdentifier("__validate"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+              ),
+            }),
+            ts.factory.createIfStatement(
+              ts.factory.createIdentifier("result.success"),
+              ts.factory.createExpressionStatement(
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier("__prune"),
+                  undefined,
+                  [ts.factory.createIdentifier("input")],
+                ),
+              ),
+            ),
+            ts.factory.createReturnStatement(
+              ts.factory.createIdentifier("result"),
+            ),
+          ],
+          true,
+        ),
+      ),
+    };
+  };
+
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      functor,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      functor,
+      result,
+    });
+  };
+}

package/src/programmers/notations/NotationAssertGeneralProgrammer.ts

@@ -1,98 +1,101 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProgrammerProps } from "../../transformers/IProgrammerProps";
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
-import { NotationGeneralProgrammer } from "./NotationGeneralProgrammer";
-
-export namespace NotationAssertGeneralProgrammer {
-  export interface IProps extends IProgrammerProps {
-    rename: (str: string) => string;
-  }
-
-  export const decompose = (props: {
-    rename: (str: string) => string;
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-    init?: ts.Expression | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
-      ...props,
-      config: {
-        equals: false,
-        guard: false,
-      },
-    });
-    const notation: FeatureProgrammer.IDecomposed =
-      NotationGeneralProgrammer.decompose({
-        ...props,
-        validated: true,
-      });
-    return {
-      functions: {
-        ...assert.functions,
-        ...notation.functions,
-      },
-      statements: [
-        ...assert.statements,
-        ...notation.statements,
-        StatementFactory.constant({
-          name: "__assert",
-          value: assert.arrow,
-        }),
-        StatementFactory.constant({
-          name: "__notation",
-          value: notation.arrow,
-        }),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
-          AssertProgrammer.Guardian.parameter(props.init),
-        ],
-        notation.arrow.type,
-        undefined,
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("__notation"),
-          undefined,
-          [
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("__assert"),
-              undefined,
-              [
-                ts.factory.createIdentifier("input"),
-                AssertProgrammer.Guardian.identifier(),
-              ],
-            ),
-          ],
-        ),
-      ),
-    };
-  };
-
-  export const write = (props: IProps): ts.CallExpression => {
-    const functor: FunctionProgrammer = new FunctionProgrammer(
-      props.modulo.getText(),
-    );
-    const result: FeatureProgrammer.IDecomposed = decompose({
-      ...props,
-      functor,
-    });
-    return FeatureProgrammer.writeDecomposed({
-      modulo: props.modulo,
-      functor,
-      result,
-    });
-  };
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+import { NotationGeneralProgrammer } from "./NotationGeneralProgrammer";
+
+export namespace NotationAssertGeneralProgrammer {
+  export interface IProps extends IProgrammerProps {
+    rename: (str: string) => string;
+  }
+
+  export const decompose = (props: {
+    rename: (str: string) => string;
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+    init?: ts.Expression | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
+      ...props,
+      config: {
+        equals: false,
+        guard: false,
+      },
+    });
+    const notation: FeatureProgrammer.IDecomposed =
+      NotationGeneralProgrammer.decompose({
+        ...props,
+        validated: true,
+      });
+    return {
+      functions: {
+        ...assert.functions,
+        ...notation.functions,
+      },
+      statements: [
+        ...assert.statements,
+        ...notation.statements,
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__notation",
+          value: notation.arrow,
+        }),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter({
+            context: props.context,
+            init: props.init,
+          }),
+        ],
+        notation.arrow.type,
+        undefined,
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("__notation"),
+          undefined,
+          [
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("__assert"),
+              undefined,
+              [
+                ts.factory.createIdentifier("input"),
+                AssertProgrammer.Guardian.identifier(),
+              ],
+            ),
+          ],
+        ),
+      ),
+    };
+  };
+
+  export const write = (props: IProps): ts.CallExpression => {
+    const functor: FunctionProgrammer = new FunctionProgrammer(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      functor,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      functor,
+      result,
+    });
+  };
+}