typia 6.10.0 → 7.0.0-dev.20240916

package/src/programmers/json/JsonIsStringifyProgrammer.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,30 +14,32 @@ import { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
 
 export namespace JsonIsStringifyProgrammer {
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     importer: FunctionImporter;
     type: ts.Type;
     name: string | undefined;
   }): 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 stringify: FeatureProgrammer.IDecomposed =
       JsonStringifyProgrammer.decompose({
         ...props,
-        project: {
-          ...props.project,
+        context: {
+          ...props.context,
           options: {
-            ...props.project.options,
+            ...props.context.options,
             functional: false,
             numeric: true,
           },
@@ -82,21 +85,18 @@ export namespace JsonIsStringifyProgrammer {
     };
   };
 
-  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,
-        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/json/JsonStringifyProgrammer.ts

@@ -14,7 +14,8 @@ import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
-import { IProject } from "../../transformers/IProject";
+import { IProgrammerProps } from "../../transformers/IProgrammerProps";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { Atomic } from "../../typings/Atomic";
 
@@ -39,17 +40,17 @@ export namespace JsonStringifyProgrammer {
   ----------------------------------------------------------- */
   export const decompose = (props: {
     validated: boolean;
-    project: IProject;
+    context: ITypiaContext;
     importer: FunctionImporter;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
-    const config: FeatureProgrammer.IConfig = configure(props.project)(
+    const config: FeatureProgrammer.IConfig = configure(props.context)(
       props.importer,
     );
     if (props.validated === false)
       config.addition = (collection) =>
-        IsProgrammer.write_function_statements(props.project)(props.importer)(
+        IsProgrammer.write_function_statements(props.context)(props.importer)(
           collection,
         );
     const composed: FeatureProgrammer.IComposed = FeatureProgrammer.compose({
@@ -70,24 +71,21 @@ export namespace JsonStringifyProgrammer {
     };
   };
 
-  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({
-        validated: false,
-        project,
-        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,
+      validated: false,
+      importer,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      importer,
+      result,
+    });
+  };
 
   const write_array_functions =
     (config: FeatureProgrammer.IConfig) =>
@@ -125,7 +123,7 @@ export namespace JsonStringifyProgrammer {
         );
 
   const write_tuple_functions =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (config: FeatureProgrammer.IConfig) =>
     (importer: FunctionImporter) =>
     (collection: MetadataCollection): ts.VariableStatement[] =>
@@ -161,7 +159,7 @@ export namespace JsonStringifyProgrammer {
     DECODERS
   ----------------------------------------------------------- */
   const decode =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (config: FeatureProgrammer.IConfig) =>
     (importer: FunctionImporter) =>
     (
@@ -509,7 +507,7 @@ export namespace JsonStringifyProgrammer {
       );
 
   const decode_tuple =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (config: FeatureProgrammer.IConfig) =>
     (importer: FunctionImporter) =>
     (
@@ -535,7 +533,7 @@ export namespace JsonStringifyProgrammer {
           );
 
   const decode_tuple_inline =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (config: FeatureProgrammer.IConfig) =>
     (importer: FunctionImporter) =>
     (
@@ -585,7 +583,7 @@ export namespace JsonStringifyProgrammer {
     };
 
   const decode_atomic =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (
       input: ts.Expression,
@@ -615,7 +613,7 @@ export namespace JsonStringifyProgrammer {
     };
 
   const decode_constant_string =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter) =>
     (
       input: ts.Expression,
@@ -632,7 +630,7 @@ export namespace JsonStringifyProgrammer {
     };
 
   const decode_to_json =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (config: FeatureProgrammer.IConfig) =>
     (importer: FunctionImporter) =>
     (
@@ -678,7 +676,7 @@ export namespace JsonStringifyProgrammer {
           );
 
   const explore_arrays =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (config: FeatureProgrammer.IConfig) =>
     (importer: FunctionImporter) =>
     (
@@ -836,7 +834,7 @@ export namespace JsonStringifyProgrammer {
   const PREFIX = "$s";
 
   const configure =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (importer: FunctionImporter): FeatureProgrammer.IConfig => {
       const config: FeatureProgrammer.IConfig = {
         types: {
@@ -875,7 +873,7 @@ export namespace JsonStringifyProgrammer {
     (project) => (importer) => (type) =>
       JsonMetadataFactory.analyze(`typia.json.${importer.method}`)(
         project.checker,
-        project.context,
+        project.transformer,
       )(type);
 
   const create_throw_error =

package/src/programmers/json/JsonValidateParseProgrammer.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";
@@ -12,7 +13,7 @@ import { FunctionImporter } from "../helpers/FunctionImporter";
 
 export namespace JsonValidateParseProgrammer {
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
     importer: FunctionImporter;
     type: ts.Type;
@@ -21,15 +22,17 @@ export namespace JsonValidateParseProgrammer {
     const validate: FeatureProgrammer.IDecomposed =
       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,
+        },
       });
     return {
       functions: validate.functions,
@@ -44,7 +47,7 @@ export namespace JsonValidateParseProgrammer {
         ts.factory.createTypeReferenceNode(
           `typia.IValidation<typia.Primitive<${
             props.name ??
-            TypeFactory.getFullName(props.project.checker)(props.type)
+            TypeFactory.getFullName(props.context.checker)(props.type)
           }>>`,
         ),
         undefined,
@@ -66,22 +69,21 @@ export namespace JsonValidateParseProgrammer {
     };
   };
 
-  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({
+      context: props.context,
+      modulo: props.modulo,
+      importer,
+      type: props.type,
+      name: props.name,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      importer,
+      result,
+    });
+  };
 }

package/src/programmers/json/JsonValidateStringifyProgrammer.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 { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
 
 export namespace JsonValidateStringifyProgrammer {
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
     importer: FunctionImporter;
     type: ts.Type;
@@ -22,15 +23,17 @@ export namespace JsonValidateStringifyProgrammer {
     const validate: FeatureProgrammer.IDecomposed =
       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 stringify: FeatureProgrammer.IDecomposed =
       JsonStringifyProgrammer.decompose({
@@ -90,22 +93,21 @@ export namespace JsonValidateStringifyProgrammer {
     };
   };
 
-  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({
+      context: props.context,
+      modulo: props.modulo,
+      importer,
+      type: props.type,
+      name: props.name,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      importer,
+      result,
+    });
+  };
 }

package/src/programmers/misc/MiscAssertCloneProgrammer.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 { AssertProgrammer } from "../AssertProgrammer";
 import { FeatureProgrammer } from "../FeatureProgrammer";
@@ -13,16 +14,18 @@ import { MiscCloneProgrammer } from "./MiscCloneProgrammer";
 
 export namespace MiscAssertCloneProgrammer {
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     importer: FunctionImporter;
     type: ts.Type;
     name: string | undefined;
-    init: ts.Expression | undefined;
+    init?: ts.Expression | undefined;
   }): FeatureProgrammer.IDecomposed => {
     const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
       ...props,
-      equals: false,
-      guard: false,
+      config: {
+        equals: false,
+        guard: false,
+      },
     });
     const clone: FeatureProgrammer.IDecomposed = MiscCloneProgrammer.decompose({
       ...props,
@@ -66,22 +69,18 @@ export namespace MiscAssertCloneProgrammer {
     };
   };
 
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string, init?: ts.Expression): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        importer,
-        type,
-        name,
-        init,
-      });
-      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/misc/MiscAssertPruneProgrammer.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 { AssertProgrammer } from "../AssertProgrammer";
 import { FeatureProgrammer } from "../FeatureProgrammer";
@@ -13,16 +14,18 @@ import { MiscPruneProgrammer } from "./MiscPruneProgrammer";
 
 export namespace MiscAssertPruneProgrammer {
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     importer: FunctionImporter;
     type: ts.Type;
     name: string | undefined;
-    init: ts.Expression | undefined;
+    init?: ts.Expression | undefined;
   }): FeatureProgrammer.IDecomposed => {
     const assert: FeatureProgrammer.IDecomposed = AssertProgrammer.decompose({
       ...props,
-      equals: false,
-      guard: false,
+      config: {
+        equals: false,
+        guard: false,
+      },
     });
     const prune: FeatureProgrammer.IDecomposed = MiscPruneProgrammer.decompose({
       ...props,
@@ -48,7 +51,7 @@ export namespace MiscAssertPruneProgrammer {
         ],
         ts.factory.createTypeReferenceNode(
           props.name ??
-            TypeFactory.getFullName(props.project.checker)(props.type),
+            TypeFactory.getFullName(props.context.checker)(props.type),
         ),
         undefined,
         ts.factory.createBlock(
@@ -84,22 +87,18 @@ export namespace MiscAssertPruneProgrammer {
     };
   };
 
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (type: ts.Type, name?: string, init?: ts.Expression): ts.CallExpression => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        project,
-        importer,
-        type,
-        name,
-        init,
-      });
-      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,
+    });
+  };
 }