typia 7.0.0-dev.20241005 → 7.0.0-dev.20241008

package/src/programmers/misc/MiscValidatePruneProgrammer.ts

@@ -52,15 +52,19 @@ export namespace MiscValidatePruneProgrammer {
         undefined,
         undefined,
         [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createTypeReferenceNode(
-          `typia.IValidation<${
-            props.name ??
-            TypeFactory.getFullName({
-              checker: props.context.checker,
-              type: props.type,
-            })
-          }>`,
-        ),
+        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(
           [

package/src/programmers/notations/NotationAssertGeneralProgrammer.ts

@@ -59,7 +59,10 @@ export namespace NotationAssertGeneralProgrammer {
         undefined,
         [
           IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
-          AssertProgrammer.Guardian.parameter(props.init),
+          AssertProgrammer.Guardian.parameter({
+            context: props.context,
+            init: props.init,
+          }),
         ],
         notation.arrow.type,
         undefined,

package/src/programmers/notations/NotationGeneralProgrammer.ts

@@ -35,8 +35,14 @@ export namespace NotationGeneralProgrammer {
 
   export const returnType = (props: {
     rename: (str: string) => string;
+    context: ITypiaContext;
     type: string;
-  }) => `typia.${StringUtil.capitalize(props.rename.name)}Case<${props.type}>`;
+  }) =>
+    props.context.importer.type({
+      file: "typia",
+      name: `${StringUtil.capitalize(props.rename.name)}Case`,
+      arguments: [ts.factory.createTypeReferenceNode(props.type)],
+    });
 
   export const decompose = (props: {
     rename: (str: string) => string;
@@ -65,17 +71,16 @@ export namespace NotationGeneralProgrammer {
         undefined,
         undefined,
         composed.parameters,
-        ts.factory.createTypeReferenceNode(
-          returnType({
-            rename: props.rename,
-            type:
-              props.name ??
-              TypeFactory.getFullName({
-                checker: props.context.checker,
-                type: props.type,
-              }),
-          }),
-        ),
+        returnType({
+          rename: props.rename,
+          context: props.context,
+          type:
+            props.name ??
+            TypeFactory.getFullName({
+              checker: props.context.checker,
+              type: props.type,
+            }),
+        }),
         undefined,
         composed.body,
       ),
@@ -807,17 +812,16 @@ export namespace NotationGeneralProgrammer {
               TypeFactory.getFullName({ checker: props.context.checker, type }),
           ),
         output: (type, name) =>
-          ts.factory.createTypeReferenceNode(
-            returnType({
-              rename: props.rename,
-              type:
-                name ??
-                TypeFactory.getFullName({
-                  checker: props.context.checker,
-                  type,
-                }),
-            }),
-          ),
+          returnType({
+            rename: props.rename,
+            context: props.context,
+            type:
+              name ??
+              TypeFactory.getFullName({
+                checker: props.context.checker,
+                type,
+              }),
+          }),
       },
       prefix: PREFIX,
       trace: false,

package/src/programmers/notations/NotationValidateGeneralProgrammer.ts

@@ -56,9 +56,11 @@ export namespace NotationValidateGeneralProgrammer {
         undefined,
         undefined,
         [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createTypeReferenceNode("typia.IValidation", [
-          notation.arrow.type ?? TypeFactory.keyword("any"),
-        ]),
+        props.context.importer.type({
+          file: "typia",
+          name: "IValidation",
+          arguments: [notation.arrow.type ?? TypeFactory.keyword("any")],
+        }),
         undefined,
         ts.factory.createBlock(
           [

package/src/programmers/protobuf/ProtobufAssertDecodeProgrammer.ts

@@ -58,7 +58,10 @@ export namespace ProtobufAssertDecodeProgrammer {
         undefined,
         [
           ...decode.arrow.parameters,
-          AssertProgrammer.Guardian.parameter(props.init),
+          AssertProgrammer.Guardian.parameter({
+            context: props.context,
+            init: props.init,
+          }),
         ],
         decode.arrow.type,
         undefined,

package/src/programmers/protobuf/ProtobufAssertEncodeProgrammer.ts

@@ -60,7 +60,10 @@ export namespace ProtobufAssertEncodeProgrammer {
         undefined,
         [
           IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
-          AssertProgrammer.Guardian.parameter(props.init),
+          AssertProgrammer.Guardian.parameter({
+            context: props.context,
+            init: props.init,
+          }),
         ],
         encode.arrow.type,
         undefined,

package/src/programmers/protobuf/ProtobufDecodeProgrammer.ts

@@ -66,13 +66,10 @@ export namespace ProtobufDecodeProgrammer {
             ts.factory.createTypeReferenceNode("Uint8Array"),
           ),
         ],
-        ts.factory.createImportTypeNode(
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral("typia"),
-          ),
-          undefined,
-          ts.factory.createIdentifier("Resolved"),
-          [
+        props.context.importer.type({
+          file: "typia",
+          name: "Resolved",
+          arguments: [
             ts.factory.createTypeReferenceNode(
               props.name ??
                 TypeFactory.getFullName({
@@ -81,7 +78,7 @@ export namespace ProtobufDecodeProgrammer {
                 }),
             ),
           ],
-        ),
+        }),
         undefined,
         ts.factory.createBlock(
           [

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -1,201 +1,201 @@
-import ts from "typescript";
-
-import { MetadataCollection } from "../../factories/MetadataCollection";
-import { ProtobufFactory } from "../../factories/ProtobufFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { MapUtil } from "../../utils/MapUtil";
-import { NameEncoder } from "../../utils/NameEncoder";
-
-import { ProtobufUtil } from "../helpers/ProtobufUtil";
-
-export namespace ProtobufMessageProgrammer {
-  export interface IProps {
-    context: ITypiaContext;
-    type: ts.Type;
-  }
-  export const write = (props: IProps) => {
-    // PARSE TARGET TYPE
-    const collection: MetadataCollection = new MetadataCollection();
-    ProtobufFactory.metadata({
-      method: "message",
-      checker: props.context.checker,
-      transformer: props.context.transformer,
-      collection,
-      type: props.type,
-    });
-
-    // STRINGIFY
-    const hierarchies: Map<string, Hierarchy> = new Map();
-    for (const object of collection.objects())
-      if (is_dynamic_object(object) === false)
-        emplace({
-          hierarchies,
-          object,
-        });
-
-    const content: string =
-      `syntax = "proto3";\n\n` +
-      [...hierarchies.values()]
-        .map((hier) => write_hierarchy(hier))
-        .join("\n\n");
-
-    // RETURNS
-    return ts.factory.createStringLiteral(content);
-  };
-
-  const emplace = (props: {
-    hierarchies: Map<string, Hierarchy>;
-    object: MetadataObject;
-  }) => {
-    let hierarchies: Map<string, Hierarchy> = props.hierarchies;
-    const accessors: string[] = props.object.name.split(".");
-    accessors.forEach((access, i) => {
-      const hierarchy: Hierarchy = MapUtil.take(hierarchies, access, () => ({
-        key: access,
-        object: null!,
-        children: new Map(),
-      }));
-      hierarchies = hierarchy.children;
-      if (i === accessors.length - 1) hierarchy.object = props.object;
-    });
-  };
-
-  const is_dynamic_object = (object: MetadataObject): boolean =>
-    object.properties.length === 1 &&
-    object.properties[0]!.key.isSoleLiteral() === false;
-
-  const write_hierarchy = (hierarchy: Hierarchy): string => {
-    const elements: string[] = [
-      `message ${NameEncoder.encode(hierarchy.key)} {`,
-    ];
-    if (hierarchy.object !== null) {
-      const text: string = write_object(hierarchy.object);
-      elements.push(...text.split("\n").map((str) => `${TAB}${str}`));
-    }
-    if (hierarchy.children.size)
-      elements.push(
-        [...hierarchy.children.values()]
-          .map((child) => write_hierarchy(child))
-          .map((body) =>
-            body
-              .split("\n")
-              .map((line) => `${TAB}${line}`)
-              .join("\n"),
-          )
-          .join("\n\n"),
-      );
-    elements.push("}");
-    return elements.join("\n");
-  };
-
-  const write_object = (object: MetadataObject): string => {
-    const sequence: IPointer<number> = { value: 0 };
-    return object.properties
-      .map((p) => {
-        const key: string = p.key.getSoleLiteral()!;
-        const type: string = decode({
-          sequence,
-          metadata: p.value,
-        });
-        return type.indexOf("${name}") !== -1
-          ? type.replace("${name}", key)
-          : `${
-              p.value.arrays.length || type.startsWith("map<")
-                ? ""
-                : !p.value.isRequired() || p.value.nullable
-                  ? "optional "
-                  : "required "
-            }${type} ${key} = ${++sequence.value};`;
-      })
-      .join("\n");
-  };
-
-  /* -----------------------------------------------------------
-        DECODERS
-    ----------------------------------------------------------- */
-  const decode = (props: {
-    sequence: IPointer<number>;
-    metadata: Metadata;
-  }): string => {
-    const elements: Set<string> = new Set();
-    if (props.metadata.natives.length) elements.add("bytes");
-    for (const atomic of ProtobufUtil.getAtomics(props.metadata))
-      elements.add(atomic);
-    for (const array of props.metadata.arrays)
-      elements.add(
-        `repeated ${decode({
-          sequence: props.sequence,
-          metadata: array.type.value,
-        })}`,
-      );
-    for (const obj of props.metadata.objects)
-      elements.add(
-        is_dynamic_object(obj)
-          ? decode_map({
-              sequence: props.sequence,
-              entry: MetadataProperty.create({
-                ...obj.properties[0]!,
-                key: (() => {
-                  const key: Metadata = Metadata.initialize();
-                  key.atomics.push(
-                    MetadataAtomic.create({
-                      type: "string",
-                      tags: [],
-                    }),
-                  );
-                  return key;
-                })(),
-              }),
-            })
-          : NameEncoder.encode(obj.name),
-      );
-    for (const entry of props.metadata.maps)
-      elements.add(
-        decode_map({
-          sequence: props.sequence,
-          entry,
-        }),
-      );
-    return elements.size === 1
-      ? [...elements][0]!
-      : [
-          "oneof ${name} {",
-          ...[...elements].map((str) => {
-            const index: number = ++props.sequence.value;
-            return `${TAB}${str} v${index} = ${index};`;
-          }),
-          "}",
-        ].join("\n");
-  };
-
-  const decode_map = (props: {
-    sequence: IPointer<number>;
-    entry: Metadata.Entry;
-  }): string =>
-    `map<${decode({
-      sequence: props.sequence,
-      metadata: props.entry.key,
-    })}, ${decode({
-      sequence: props.sequence,
-      metadata: props.entry.value,
-    })}>`;
-}
-
-interface Hierarchy {
-  key: string;
-  object: MetadataObject | null;
-  children: Map<string, Hierarchy>;
-}
-
-interface IPointer<T> {
-  value: T;
-}
-
-const TAB = " ".repeat(2);
+import ts from "typescript";
+
+import { MetadataCollection } from "../../factories/MetadataCollection";
+import { ProtobufFactory } from "../../factories/ProtobufFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { MapUtil } from "../../utils/MapUtil";
+import { NameEncoder } from "../../utils/NameEncoder";
+
+import { ProtobufUtil } from "../helpers/ProtobufUtil";
+
+export namespace ProtobufMessageProgrammer {
+  export interface IProps {
+    context: ITypiaContext;
+    type: ts.Type;
+  }
+  export const write = (props: IProps) => {
+    // PARSE TARGET TYPE
+    const collection: MetadataCollection = new MetadataCollection();
+    ProtobufFactory.metadata({
+      method: "message",
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      collection,
+      type: props.type,
+    });
+
+    // STRINGIFY
+    const hierarchies: Map<string, Hierarchy> = new Map();
+    for (const object of collection.objects())
+      if (is_dynamic_object(object) === false)
+        emplace({
+          hierarchies,
+          object,
+        });
+
+    const content: string =
+      `syntax = "proto3";\n\n` +
+      [...hierarchies.values()]
+        .map((hier) => write_hierarchy(hier))
+        .join("\n\n");
+
+    // RETURNS
+    return ts.factory.createStringLiteral(content);
+  };
+
+  const emplace = (props: {
+    hierarchies: Map<string, Hierarchy>;
+    object: MetadataObject;
+  }) => {
+    let hierarchies: Map<string, Hierarchy> = props.hierarchies;
+    const accessors: string[] = props.object.name.split(".");
+    accessors.forEach((access, i) => {
+      const hierarchy: Hierarchy = MapUtil.take(hierarchies, access, () => ({
+        key: access,
+        object: null!,
+        children: new Map(),
+      }));
+      hierarchies = hierarchy.children;
+      if (i === accessors.length - 1) hierarchy.object = props.object;
+    });
+  };
+
+  const is_dynamic_object = (object: MetadataObject): boolean =>
+    object.properties.length === 1 &&
+    object.properties[0]!.key.isSoleLiteral() === false;
+
+  const write_hierarchy = (hierarchy: Hierarchy): string => {
+    const elements: string[] = [
+      `message ${NameEncoder.encode(hierarchy.key)} {`,
+    ];
+    if (hierarchy.object !== null) {
+      const text: string = write_object(hierarchy.object);
+      elements.push(...text.split("\n").map((str) => `${TAB}${str}`));
+    }
+    if (hierarchy.children.size)
+      elements.push(
+        [...hierarchy.children.values()]
+          .map((child) => write_hierarchy(child))
+          .map((body) =>
+            body
+              .split("\n")
+              .map((line) => `${TAB}${line}`)
+              .join("\n"),
+          )
+          .join("\n\n"),
+      );
+    elements.push("}");
+    return elements.join("\n");
+  };
+
+  const write_object = (object: MetadataObject): string => {
+    const sequence: IPointer<number> = { value: 0 };
+    return object.properties
+      .map((p) => {
+        const key: string = p.key.getSoleLiteral()!;
+        const type: string = decode({
+          sequence,
+          metadata: p.value,
+        });
+        return type.indexOf("${name}") !== -1
+          ? type.replace("${name}", key)
+          : `${
+              p.value.arrays.length || type.startsWith("map<")
+                ? ""
+                : !p.value.isRequired() || p.value.nullable
+                  ? "optional "
+                  : "required "
+            }${type} ${key} = ${++sequence.value};`;
+      })
+      .join("\n");
+  };
+
+  /* -----------------------------------------------------------
+        DECODERS
+    ----------------------------------------------------------- */
+  const decode = (props: {
+    sequence: IPointer<number>;
+    metadata: Metadata;
+  }): string => {
+    const elements: Set<string> = new Set();
+    if (props.metadata.natives.length) elements.add("bytes");
+    for (const atomic of ProtobufUtil.getAtomics(props.metadata))
+      elements.add(atomic);
+    for (const array of props.metadata.arrays)
+      elements.add(
+        `repeated ${decode({
+          sequence: props.sequence,
+          metadata: array.type.value,
+        })}`,
+      );
+    for (const obj of props.metadata.objects)
+      elements.add(
+        is_dynamic_object(obj)
+          ? decode_map({
+              sequence: props.sequence,
+              entry: MetadataProperty.create({
+                ...obj.properties[0]!,
+                key: (() => {
+                  const key: Metadata = Metadata.initialize();
+                  key.atomics.push(
+                    MetadataAtomic.create({
+                      type: "string",
+                      tags: [],
+                    }),
+                  );
+                  return key;
+                })(),
+              }),
+            })
+          : NameEncoder.encode(obj.name),
+      );
+    for (const entry of props.metadata.maps)
+      elements.add(
+        decode_map({
+          sequence: props.sequence,
+          entry,
+        }),
+      );
+    return elements.size === 1
+      ? [...elements][0]!
+      : [
+          "oneof ${name} {",
+          ...[...elements].map((str) => {
+            const index: number = ++props.sequence.value;
+            return `${TAB}${str} v${index} = ${index};`;
+          }),
+          "}",
+        ].join("\n");
+  };
+
+  const decode_map = (props: {
+    sequence: IPointer<number>;
+    entry: Metadata.Entry;
+  }): string =>
+    `map<${decode({
+      sequence: props.sequence,
+      metadata: props.entry.key,
+    })}, ${decode({
+      sequence: props.sequence,
+      metadata: props.entry.value,
+    })}>`;
+}
+
+interface Hierarchy {
+  key: string;
+  object: MetadataObject | null;
+  children: Map<string, Hierarchy>;
+}
+
+interface IPointer<T> {
+  value: T;
+}
+
+const TAB = " ".repeat(2);

package/src/programmers/protobuf/ProtobufValidateDecodeProgrammer.ts

@@ -54,9 +54,11 @@ export namespace ProtobufValidateDecodeProgrammer {
         undefined,
         undefined,
         decode.arrow.parameters,
-        ts.factory.createTypeReferenceNode("typia.IValidation", [
-          decode.arrow.type ?? TypeFactory.keyword("any"),
-        ]),
+        props.context.importer.type({
+          file: "typia",
+          name: "IValidation",
+          arguments: [decode.arrow.type ?? TypeFactory.keyword("any")],
+        }),
         undefined,
         ts.factory.createCallExpression(
           ts.factory.createIdentifier("__validate"),

package/src/programmers/protobuf/ProtobufValidateEncodeProgrammer.ts

@@ -56,9 +56,14 @@ export namespace ProtobufValidateEncodeProgrammer {
         undefined,
         undefined,
         [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createTypeReferenceNode("typia.IValidation", [
-          encode.arrow.type ?? ts.factory.createTypeReferenceNode("Uint8Array"),
-        ]),
+        props.context.importer.type({
+          file: "typia",
+          name: "IValidation",
+          arguments: [
+            encode.arrow.type ??
+              ts.factory.createTypeReferenceNode("Uint8Array"),
+          ],
+        }),
         undefined,
         ts.factory.createBlock(
           [