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

package/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts

@@ -91,7 +91,7 @@ export namespace FunctionalAssertFunctionProgrammer {
           ts.factory.createVariableDeclaration(
             name,
             undefined,
-            AssertProgrammer.Guardian.type(),
+            AssertProgrammer.Guardian.type(props.context),
             props.init ??
               props.context.importer.internal(
                 "functionalTypeGuardErrorFactory",

package/src/programmers/functional/FunctionalValidateFunctionProgrammer.ts

@@ -37,6 +37,7 @@ export namespace FunctionalValidateFunctionProgrammer {
               undefined,
               props.declaration.parameters,
               getReturnTypeNode({
+                context: props.context,
                 declaration: props.declaration,
                 async: r.async,
               }),
@@ -91,6 +92,7 @@ export namespace FunctionalValidateFunctionProgrammer {
     );
 
   export const getReturnTypeNode = (props: {
+    context: ITypiaContext;
     declaration: ts.FunctionDeclaration;
     async: boolean;
   }): ts.TypeNode | undefined =>
@@ -98,26 +100,20 @@ export namespace FunctionalValidateFunctionProgrammer {
       ? props.async
         ? !!(props.declaration.type! as ts.TypeReferenceNode).typeArguments?.[0]
           ? ts.factory.createTypeReferenceNode("Promise", [
-              ts.factory.createImportTypeNode(
-                ts.factory.createLiteralTypeNode(
-                  ts.factory.createStringLiteral("typia"),
-                ),
-                undefined,
-                ts.factory.createIdentifier("IValidation"),
-                [
+              props.context.importer.type({
+                file: "typia",
+                name: "IValidation",
+                arguments: [
                   (props.declaration.type! as ts.TypeReferenceNode)
                     .typeArguments![0]!,
                 ],
-              ),
+              }),
             ])
           : undefined
-        : ts.factory.createImportTypeNode(
-            ts.factory.createLiteralTypeNode(
-              ts.factory.createStringLiteral("typia"),
-            ),
-            undefined,
-            ts.factory.createIdentifier("IValidation"),
-            [props.declaration.type],
-          )
+        : props.context.importer.type({
+            file: "typia",
+            name: "IValidation",
+            arguments: [props.declaration.type],
+          })
       : undefined;
 }

package/src/programmers/functional/FunctionalValidateParametersProgrammer.ts

@@ -61,6 +61,7 @@ export namespace FunctionalValidateParametersProgrammer {
               undefined,
               props.declaration.parameters,
               FunctionalValidateFunctionProgrammer.getReturnTypeNode({
+                context: props.context,
                 declaration: props.declaration,
                 async,
               }),
@@ -114,18 +115,10 @@ export namespace FunctionalValidateParametersProgrammer {
               undefined,
               [ts.factory.createIdentifier(p.name.getText())],
             ),
-            ts.factory.createImportTypeNode(
-              ts.factory.createLiteralTypeNode(
-                ts.factory.createStringLiteral("typia"),
-              ),
-              undefined,
-              ts.factory.createQualifiedName(
-                ts.factory.createIdentifier("IValidation"),
-                ts.factory.createIdentifier("IFailure"),
-              ),
-              undefined,
-              false,
-            ),
+            props.context.importer.type({
+              file: "typia",
+              name: "IValidation.IFailure",
+            }),
           ),
         ),
         true,

package/src/programmers/functional/FunctionalValidateReturnProgrammer.ts

@@ -50,6 +50,7 @@ export namespace FunctionalValidateReturnProgrammer {
               undefined,
               props.declaration.parameters,
               FunctionalValidateFunctionProgrammer.getReturnTypeNode({
+                context: props.context,
                 declaration: props.declaration,
                 async: result.async,
               }),

package/src/programmers/helpers/OptionPredicator.ts

@@ -1,15 +1,15 @@
-import { ITransformOptions } from "../../transformers/ITransformOptions";
-
-export namespace OptionPredicator {
-  export const numeric = (options: ITransformOptions): boolean =>
-    finite(options) || options.numeric === true;
-
-  export const functional = (options: ITransformOptions): boolean =>
-    options.functional === true;
-
-  export const finite = (options: ITransformOptions): boolean =>
-    options.finite === true;
-
-  export const undefined = (options: ITransformOptions): boolean =>
-    options.undefined !== false;
-}
+import { ITransformOptions } from "../../transformers/ITransformOptions";
+
+export namespace OptionPredicator {
+  export const numeric = (options: ITransformOptions): boolean =>
+    finite(options) || options.numeric === true;
+
+  export const functional = (options: ITransformOptions): boolean =>
+    options.functional === true;
+
+  export const finite = (options: ITransformOptions): boolean =>
+    options.finite === true;
+
+  export const undefined = (options: ITransformOptions): boolean =>
+    options.undefined !== false;
+}

package/src/programmers/http/HttpAssertFormDataProgrammer.ts

@@ -1,96 +1,99 @@
-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 { HttpFormDataProgrammer } from "./HttpFormDataProgrammer";
-
-export namespace HttpAssertFormDataProgrammer {
-  export const decompose = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-    init?: ts.Expression | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
-      ...props,
-      context: {
-        ...props.context,
-        options: {
-          ...props.context.options,
-          functional: false,
-          numeric: true,
-        },
-      },
-      config: {
-        equals: false,
-        guard: false,
-      },
-    });
-    const decode: FeatureProgrammer.IDecomposed =
-      HttpFormDataProgrammer.decompose(props);
-    return {
-      functions: {
-        ...assert.functions,
-        ...decode.functions,
-      },
-      statements: [
-        ...assert.statements,
-        ...decode.statements,
-        StatementFactory.constant({
-          name: "__assert",
-          value: assert.arrow,
-        }),
-        StatementFactory.constant({
-          name: "__decode",
-          value: decode.arrow,
-        }),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
-          AssertProgrammer.Guardian.parameter(props.init),
-        ],
-        decode.arrow.type,
-        undefined,
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("__assert"),
-          undefined,
-          [
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("__decode"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-            AssertProgrammer.Guardian.identifier(),
-          ],
-        ),
-      ),
-    };
-  };
-
-  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 { AssertProgrammer } from "../AssertProgrammer";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+import { HttpFormDataProgrammer } from "./HttpFormDataProgrammer";
+
+export namespace HttpAssertFormDataProgrammer {
+  export const decompose = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+    init?: ts.Expression | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
+      ...props,
+      context: {
+        ...props.context,
+        options: {
+          ...props.context.options,
+          functional: false,
+          numeric: true,
+        },
+      },
+      config: {
+        equals: false,
+        guard: false,
+      },
+    });
+    const decode: FeatureProgrammer.IDecomposed =
+      HttpFormDataProgrammer.decompose(props);
+    return {
+      functions: {
+        ...assert.functions,
+        ...decode.functions,
+      },
+      statements: [
+        ...assert.statements,
+        ...decode.statements,
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter({
+            context: props.context,
+            init: props.init,
+          }),
+        ],
+        decode.arrow.type,
+        undefined,
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("__assert"),
+          undefined,
+          [
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("__decode"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+            AssertProgrammer.Guardian.identifier(),
+          ],
+        ),
+      ),
+    };
+  };
+
+  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/http/HttpAssertHeadersProgrammer.ts

@@ -1,96 +1,99 @@
-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 { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
-
-export namespace HttpAssertHeadersProgrammer {
-  export const decompose = (props: {
-    context: ITypiaContext;
-    functor: FunctionProgrammer;
-    type: ts.Type;
-    name: string | undefined;
-    init?: ts.Expression | undefined;
-  }): FeatureProgrammer.IDecomposed => {
-    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
-      ...props,
-      context: {
-        ...props.context,
-        options: {
-          ...props.context.options,
-          functional: false,
-          numeric: false,
-        },
-      },
-      config: {
-        equals: false,
-        guard: false,
-      },
-    });
-    const decode: FeatureProgrammer.IDecomposed =
-      HttpHeadersProgrammer.decompose(props);
-    return {
-      functions: {
-        ...assert.functions,
-        ...decode.functions,
-      },
-      statements: [
-        ...assert.statements,
-        ...decode.statements,
-        StatementFactory.constant({
-          name: "__assert",
-          value: assert.arrow,
-        }),
-        StatementFactory.constant({
-          name: "__decode",
-          value: decode.arrow,
-        }),
-      ],
-      arrow: ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [
-          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
-          AssertProgrammer.Guardian.parameter(props.init),
-        ],
-        decode.arrow.type,
-        undefined,
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("__assert"),
-          undefined,
-          [
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("__decode"),
-              undefined,
-              [ts.factory.createIdentifier("input")],
-            ),
-            AssertProgrammer.Guardian.identifier(),
-          ],
-        ),
-      ),
-    };
-  };
-
-  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 { AssertProgrammer } from "../AssertProgrammer";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
+import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
+
+export namespace HttpAssertHeadersProgrammer {
+  export const decompose = (props: {
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
+    type: ts.Type;
+    name: string | undefined;
+    init?: ts.Expression | undefined;
+  }): FeatureProgrammer.IDecomposed => {
+    const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
+      ...props,
+      context: {
+        ...props.context,
+        options: {
+          ...props.context.options,
+          functional: false,
+          numeric: false,
+        },
+      },
+      config: {
+        equals: false,
+        guard: false,
+      },
+    });
+    const decode: FeatureProgrammer.IDecomposed =
+      HttpHeadersProgrammer.decompose(props);
+    return {
+      functions: {
+        ...assert.functions,
+        ...decode.functions,
+      },
+      statements: [
+        ...assert.statements,
+        ...decode.statements,
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
+      ],
+      arrow: ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [
+          IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
+          AssertProgrammer.Guardian.parameter({
+            context: props.context,
+            init: props.init,
+          }),
+        ],
+        decode.arrow.type,
+        undefined,
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("__assert"),
+          undefined,
+          [
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("__decode"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+            AssertProgrammer.Guardian.identifier(),
+          ],
+        ),
+      ),
+    };
+  };
+
+  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,
+    });
+  };
+}