typia 6.10.1-dev.20240914 → 7.0.0-dev.20240918

package/src/programmers/protobuf/ProtobufDecodeProgrammer.ts

@@ -14,7 +14,8 @@ import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
-import { IProject } from "../../transformers/IProject";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
 
@@ -24,17 +25,20 @@ import { ProtobufUtil } from "../helpers/ProtobufUtil";
 
 export namespace ProtobufDecodeProgrammer {
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
     importer: FunctionImporter;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
     const collection: MetadataCollection = new MetadataCollection();
-    const meta: Metadata = ProtobufFactory.metadata(props.modulo.getText())(
-      props.project.checker,
-      props.project.context,
-    )(collection)(props.type);
+    const meta: Metadata = ProtobufFactory.metadata({
+      method: props.modulo.getText(),
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      collection,
+      type: props.type,
+    });
     return {
       functions: Object.fromEntries(
         collection
@@ -44,7 +48,7 @@ export namespace ProtobufDecodeProgrammer {
             `${PREFIX}o${obj.index}`,
             StatementFactory.constant(
               props.importer.useLocal(`${PREFIX}o${obj.index}`),
-              write_object_function(props.project)(props.importer)(obj),
+              write_object_function(props.context)(props.importer)(obj),
             ),
           ]),
       ),
@@ -67,7 +71,7 @@ export namespace ProtobufDecodeProgrammer {
           [
             ts.factory.createTypeReferenceNode(
               props.name ??
-                TypeFactory.getFullName(props.project.checker)(props.type),
+                TypeFactory.getFullName(props.context.checker)(props.type),
             ),
           ],
         ),
@@ -92,27 +96,23 @@ export namespace ProtobufDecodeProgrammer {
     };
   };
 
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        modulo,
-        importer,
-        type,
-        name,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const importer: FunctionImporter = new FunctionImporter(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      importer,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      importer,
+      result,
+    });
+  };
 
   const write_object_function =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (obj: MetadataObject): ts.ArrowFunction =>
       ts.factory.createArrowFunction(
@@ -178,7 +178,7 @@ export namespace ProtobufDecodeProgrammer {
       );
 
   const write_object_function_body =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (props: { condition: ts.Expression; tag: string; output: string }) =>
     (properties: MetadataProperty[]): ts.Statement[] => {
@@ -304,7 +304,7 @@ export namespace ProtobufDecodeProgrammer {
         DECODERS
     ----------------------------------------------------------- */
   const decode_property =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (index: number) =>
     (
@@ -508,7 +508,7 @@ export namespace ProtobufDecodeProgrammer {
       );
 
   const decode_dynamic_object =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (
       accessor: ts.ElementAccessExpression | ts.PropertyAccessExpression,
@@ -551,7 +551,7 @@ export namespace ProtobufDecodeProgrammer {
     };
 
   const decode_map =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (
       accessor: ts.ElementAccessExpression | ts.PropertyAccessExpression,
@@ -581,7 +581,7 @@ export namespace ProtobufDecodeProgrammer {
       })(map, required);
 
   const decode_entry =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (props: {
       initializer: () => ts.Expression;

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -14,7 +14,8 @@ import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
-import { IProject } from "../../transformers/IProject";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
 
@@ -28,17 +29,20 @@ import { decode_union_object } from "../internal/decode_union_object";
 
 export namespace ProtobufEncodeProgrammer {
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
     importer: FunctionImporter;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
     const collection: MetadataCollection = new MetadataCollection();
-    const meta: Metadata = ProtobufFactory.metadata(props.modulo.getText())(
-      props.project.checker,
-      props.project.context,
-    )(collection)(props.type);
+    const meta: Metadata = ProtobufFactory.metadata({
+      method: props.modulo.getText(),
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      collection,
+      type: props.type,
+    });
 
     const callEncoder = (writer: string) => (factory: ts.NewExpression) =>
       StatementFactory.constant(
@@ -53,7 +57,7 @@ export namespace ProtobufEncodeProgrammer {
       functions: {
         encoder: StatementFactory.constant(
           props.importer.useLocal("encoder"),
-          write_encoder(props.project)(props.importer)(collection)(meta),
+          write_encoder(props.context)(props.importer)(collection)(meta),
         ),
       },
       statements: [],
@@ -65,7 +69,7 @@ export namespace ProtobufEncodeProgrammer {
             "input",
             ts.factory.createTypeReferenceNode(
               props.name ??
-                TypeFactory.getFullName(props.project.checker)(props.type),
+                TypeFactory.getFullName(props.context.checker)(props.type),
             ),
           ),
         ],
@@ -101,27 +105,23 @@ export namespace ProtobufEncodeProgrammer {
     };
   };
 
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        modulo,
-        importer,
-        type,
-        name,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const importer: FunctionImporter = new FunctionImporter(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      importer,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      importer,
+      result,
+    });
+  };
 
   const write_encoder =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (collection: MetadataCollection) =>
     (meta: Metadata): ts.ArrowFunction => {
@@ -180,7 +180,7 @@ export namespace ProtobufEncodeProgrammer {
     };
 
   const write_object_function =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (
       input: ts.Expression,
@@ -221,7 +221,7 @@ export namespace ProtobufEncodeProgrammer {
         DECODERS
     ----------------------------------------------------------- */
   const decode =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (index: number | null) =>
     (
@@ -399,7 +399,7 @@ export namespace ProtobufEncodeProgrammer {
       );
 
   const decode_map =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (index: number) =>
     (
@@ -450,7 +450,7 @@ export namespace ProtobufEncodeProgrammer {
     };
 
   const decode_object =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (index: number | null) =>
     (
@@ -518,7 +518,7 @@ export namespace ProtobufEncodeProgrammer {
     };
 
   const decode_array =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (index: number) =>
     (
@@ -724,7 +724,7 @@ export namespace ProtobufEncodeProgrammer {
         EXPLORERS
     ----------------------------------------------------------- */
   const explore_objects =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (level: number) =>
     (index: number | null) =>

package/src/programmers/protobuf/ProtobufIsDecodeProgrammer.ts

@@ -3,7 +3,8 @@ import ts from "typescript";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
@@ -12,7 +13,7 @@ import { ProtobufDecodeProgrammer } from "./ProtobufDecodeProgrammer";
 
 export namespace ProtobufIsDecodeProgrammer {
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
     importer: FunctionImporter;
     type: ts.Type;
@@ -20,15 +21,17 @@ export namespace ProtobufIsDecodeProgrammer {
   }): FeatureProgrammer.IDecomposed => {
     const is: FeatureProgrammer.IDecomposed = IsProgrammer.decompose({
       ...props,
-      project: {
-        ...props.project,
+      context: {
+        ...props.context,
         options: {
-          ...props.project.options,
+          ...props.context.options,
           functional: false,
           numeric: false,
         },
       },
-      equals: false,
+      config: {
+        equals: false,
+      },
     });
     const decode: FeatureProgrammer.IDecomposed =
       ProtobufDecodeProgrammer.decompose(props);
@@ -83,22 +86,18 @@ export namespace ProtobufIsDecodeProgrammer {
     };
   };
 
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        modulo,
-        importer,
-        type,
-        name,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const importer: FunctionImporter = new FunctionImporter(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      importer,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      importer,
+      result,
+    });
+  };
 }

package/src/programmers/protobuf/ProtobufIsEncodeProgrammer.ts

@@ -4,7 +4,8 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
@@ -13,7 +14,7 @@ import { ProtobufEncodeProgrammer } from "./ProtobufEncodeProgrammer";
 
 export namespace ProtobufIsEncodeProgrammer {
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
     importer: FunctionImporter;
     type: ts.Type;
@@ -21,15 +22,17 @@ export namespace ProtobufIsEncodeProgrammer {
   }): FeatureProgrammer.IDecomposed => {
     const is: FeatureProgrammer.IDecomposed = IsProgrammer.decompose({
       ...props,
-      project: {
-        ...props.project,
+      context: {
+        ...props.context,
         options: {
-          ...props.project.options,
+          ...props.context.options,
           functional: false,
           numeric: true,
         },
       },
-      equals: false,
+      config: {
+        equals: false,
+      },
     });
     const encode: FeatureProgrammer.IDecomposed =
       ProtobufEncodeProgrammer.decompose(props);
@@ -72,22 +75,18 @@ export namespace ProtobufIsEncodeProgrammer {
     };
   };
 
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        modulo,
-        importer,
-        type,
-        name,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const importer: FunctionImporter = new FunctionImporter(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      importer,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      importer,
+      result,
+    });
+  };
 }

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -8,7 +8,7 @@ import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
-import { IProject } from "../../transformers/IProject";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { MapUtil } from "../../utils/MapUtil";
 import { NameEncoder } from "../../utils/NameEncoder";
@@ -16,12 +16,20 @@ import { NameEncoder } from "../../utils/NameEncoder";
 import { ProtobufUtil } from "../helpers/ProtobufUtil";
 
 export namespace ProtobufMessageProgrammer {
-  export const write = (project: IProject) => (type: ts.Type) => {
+  export interface IProps {
+    context: ITypiaContext;
+    type: ts.Type;
+  }
+  export const write = (props: IProps) => {
     // PARSE TARGET TYPE
     const collection: MetadataCollection = new MetadataCollection();
-    ProtobufFactory.metadata("message")(project.checker, project.context)(
+    ProtobufFactory.metadata({
+      method: "message",
+      checker: props.context.checker,
+      transformer: props.context.transformer,
       collection,
-    )(type);
+      type: props.type,
+    });
 
     // STRINGIFY
     const hierarchies: Map<string, Hierarchy> = new Map();

package/src/programmers/protobuf/ProtobufValidateDecodeProgrammer.ts

@@ -3,7 +3,8 @@ import ts from "typescript";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { ValidateProgrammer } from "../ValidateProgrammer";
@@ -12,7 +13,7 @@ import { ProtobufDecodeProgrammer } from "./ProtobufDecodeProgrammer";
 
 export namespace ProtobufValidateDecodeProgrammer {
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
     importer: FunctionImporter;
     type: ts.Type;
@@ -20,15 +21,17 @@ export namespace ProtobufValidateDecodeProgrammer {
   }): FeatureProgrammer.IDecomposed => {
     const validate = ValidateProgrammer.decompose({
       ...props,
-      project: {
-        ...props.project,
+      context: {
+        ...props.context,
         options: {
-          ...props.project.options,
+          ...props.context.options,
           functional: false,
           numeric: false,
         },
       },
-      equals: false,
+      config: {
+        equals: false,
+      },
     });
     const decode = ProtobufDecodeProgrammer.decompose(props);
     return {
@@ -64,22 +67,18 @@ export namespace ProtobufValidateDecodeProgrammer {
     };
   };
 
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        modulo,
-        importer,
-        type,
-        name,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const importer: FunctionImporter = new FunctionImporter(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      importer,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      importer,
+      result,
+    });
+  };
 }

package/src/programmers/protobuf/ProtobufValidateEncodeProgrammer.ts

@@ -4,7 +4,8 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { ValidateProgrammer } from "../ValidateProgrammer";
@@ -13,7 +14,7 @@ import { ProtobufEncodeProgrammer } from "./ProtobufEncodeProgrammer";
 
 export namespace ProtobufValidateEncodeProgrammer {
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
     importer: FunctionImporter;
     type: ts.Type;
@@ -21,15 +22,17 @@ export namespace ProtobufValidateEncodeProgrammer {
   }): FeatureProgrammer.IDecomposed => {
     const validate = ValidateProgrammer.decompose({
       ...props,
-      project: {
-        ...props.project,
+      context: {
+        ...props.context,
         options: {
-          ...props.project.options,
+          ...props.context.options,
           functional: false,
           numeric: true,
         },
       },
-      equals: false,
+      config: {
+        equals: false,
+      },
     });
     const encode = ProtobufEncodeProgrammer.decompose(props);
     return {
@@ -88,22 +91,18 @@ export namespace ProtobufValidateEncodeProgrammer {
     };
   };
 
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        modulo,
-        importer,
-        type,
-        name,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
+  export const write = (props: IProgrammerProps): ts.CallExpression => {
+    const importer: FunctionImporter = new FunctionImporter(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      ...props,
+      importer,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      importer,
+      result,
+    });
+  };
 }

package/src/transform.ts

@@ -1,13 +1,13 @@
 import ts from "typescript";
 
 import { FileTransformer } from "./transformers/FileTransformer";
-import { IProject } from "./transformers/IProject";
 import { ITransformOptions } from "./transformers/ITransformOptions";
+import { ITypiaContext } from "./transformers/ITypiaContext";
 
 export const transform = (
   program: ts.Program,
   options: ITransformOptions | undefined,
-  extras: IProject["extras"],
+  extras: ITypiaContext["extras"],
 ): ts.TransformerFactory<ts.SourceFile> => {
   const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
   const strict: boolean =