typia 7.0.0-dev.20241002-2 → 7.0.0-dev.20241005

package/src/programmers/helpers/UnionPredicator.ts

@@ -1,77 +1,77 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-import { MapUtil } from "../../utils/MapUtil";
-
-export namespace UnionPredicator {
-  export interface ISpecialized {
-    index: number;
-    object: MetadataObject;
-    property: MetadataProperty;
-    neighbour: boolean;
-  }
-
-  export const object = (objects: MetadataObject[]): Array<ISpecialized> => {
-    // PROPERTY MATRIX
-    const matrix: Map<string, Array<MetadataProperty | null>> = new Map();
-    for (const obj of objects)
-      for (const prop of obj.properties) {
-        const key: string | null = prop.key.getSoleLiteral();
-        if (key !== null)
-          MapUtil.take(matrix, key, () =>
-            ArrayUtil.repeat(objects.length, () => null),
-          );
-      }
-    objects.forEach((obj, i) => {
-      for (const prop of obj.properties) {
-        const key: string | null = prop.key.getSoleLiteral();
-        if (key !== null) matrix.get(key)![i] = prop;
-      }
-    });
-
-    // EXPLORE SPECIALIZERS
-    const output: ISpecialized[] = [];
-    objects.forEach((obj, i) => {
-      const children: ISpecializedProperty[] = [];
-      obj.properties.forEach((prop) => {
-        // MUST BE REQUIRED
-        if (prop.value.isRequired() === false) return;
-        const key: string | null = prop.key.getSoleLiteral();
-        if (key === null) return;
-
-        // FIND NEIGHBORHOOD PROPERTIES
-        const neighbors: MetadataProperty[] = matrix
-          .get(key)!
-          .filter((oppo, k) => i !== k && oppo !== null) as MetadataProperty[];
-
-        // NO NEIGHBORHOOD
-        const unique: boolean =
-          neighbors.length === 0 ||
-          neighbors.every((n) => !Metadata.intersects(prop.value, n.value));
-        if (unique === true)
-          children.push({
-            property: prop,
-            neighbour: neighbors.length !== 0,
-          });
-      });
-      if (children.length === 0) return;
-
-      const top: ISpecializedProperty =
-        children.find((child) => child.property.value.isConstant()) ||
-        children[0]!;
-      output.push({
-        index: i,
-        object: obj,
-        ...top,
-      });
-    });
-    return output;
-  };
-}
-
-interface ISpecializedProperty {
-  property: MetadataProperty;
-  neighbour: boolean;
-}
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+import { MapUtil } from "../../utils/MapUtil";
+
+export namespace UnionPredicator {
+  export interface ISpecialized {
+    index: number;
+    object: MetadataObject;
+    property: MetadataProperty;
+    neighbour: boolean;
+  }
+
+  export const object = (objects: MetadataObject[]): Array<ISpecialized> => {
+    // PROPERTY MATRIX
+    const matrix: Map<string, Array<MetadataProperty | null>> = new Map();
+    for (const obj of objects)
+      for (const prop of obj.properties) {
+        const key: string | null = prop.key.getSoleLiteral();
+        if (key !== null)
+          MapUtil.take(matrix, key, () =>
+            ArrayUtil.repeat(objects.length, () => null),
+          );
+      }
+    objects.forEach((obj, i) => {
+      for (const prop of obj.properties) {
+        const key: string | null = prop.key.getSoleLiteral();
+        if (key !== null) matrix.get(key)![i] = prop;
+      }
+    });
+
+    // EXPLORE SPECIALIZERS
+    const output: ISpecialized[] = [];
+    objects.forEach((obj, i) => {
+      const children: ISpecializedProperty[] = [];
+      obj.properties.forEach((prop) => {
+        // MUST BE REQUIRED
+        if (prop.value.isRequired() === false) return;
+        const key: string | null = prop.key.getSoleLiteral();
+        if (key === null) return;
+
+        // FIND NEIGHBORHOOD PROPERTIES
+        const neighbors: MetadataProperty[] = matrix
+          .get(key)!
+          .filter((oppo, k) => i !== k && oppo !== null) as MetadataProperty[];
+
+        // NO NEIGHBORHOOD
+        const unique: boolean =
+          neighbors.length === 0 ||
+          neighbors.every((n) => !Metadata.intersects(prop.value, n.value));
+        if (unique === true)
+          children.push({
+            property: prop,
+            neighbour: neighbors.length !== 0,
+          });
+      });
+      if (children.length === 0) return;
+
+      const top: ISpecializedProperty =
+        children.find((child) => child.property.value.isConstant()) ||
+        children[0]!;
+      output.push({
+        index: i,
+        object: obj,
+        ...top,
+      });
+    });
+    return output;
+  };
+}
+
+interface ISpecializedProperty {
+  property: MetadataProperty;
+  neighbour: boolean;
+}

package/src/programmers/helpers/disable_function_programmer_declare.ts

@@ -0,0 +1,35 @@
+import ts from "typescript";
+
+import { FunctionProgrammer } from "./FunctionProgrammer";
+
+export const disable_function_programmer_declare = (
+  functor: FunctionProgrammer,
+): FunctionProgrammer => disable(functor) as FunctionProgrammer;
+
+const disable = (
+  functor: FunctionProgrammer,
+): MethodOnly<FunctionProgrammer> => ({
+  method: functor.method,
+  empty: (): boolean => functor.empty(),
+  use: (name: string): ts.Identifier => functor.use(name),
+  useLocal: (name: string): string => functor.useLocal(name),
+  hasLocal: (name: string): boolean => functor.hasLocal(name),
+  declare: (_modulo: ts.LeftHandSideExpression): ts.Statement[] => [],
+  declareUnions: (): ts.Statement[] => [],
+  increment: (): number => functor.increment(),
+  emplaceUnion: (
+    prefix: string,
+    name: string,
+    factory: () => ts.ArrowFunction,
+  ): string => functor.emplaceUnion(prefix, name, factory),
+  emplaceVariable: (key, value) => functor.emplaceVariable(key, value),
+  trace: (): void => functor.trace(),
+});
+
+type MethodOnly<T> = {
+  [P in keyof T]: T[P] extends Function
+    ? T[P]
+    : P extends "method"
+      ? T[P]
+      : never;
+};

package/src/programmers/http/HttpAssertFormDataProgrammer.ts

@@ -9,13 +9,13 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { AssertProgrammer } from "../AssertProgrammer";
 import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { HttpFormDataProgrammer } from "./HttpFormDataProgrammer";
 
 export namespace HttpAssertFormDataProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
     init?: ts.Expression | undefined;
@@ -80,16 +80,16 @@ export namespace HttpAssertFormDataProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/http/HttpAssertHeadersProgrammer.ts

@@ -9,13 +9,13 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { AssertProgrammer } from "../AssertProgrammer";
 import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { HttpHeadersProgrammer } from "./HttpHeadersProgrammer";
 
 export namespace HttpAssertHeadersProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
     init?: ts.Expression | undefined;
@@ -80,16 +80,16 @@ export namespace HttpAssertHeadersProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/http/HttpAssertQueryProgrammer.ts

@@ -9,7 +9,7 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { AssertProgrammer } from "../AssertProgrammer";
 import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { HttpQueryProgrammer } from "./HttpQueryProgrammer";
 
 export namespace HttpAssertQueryProgrammer {
@@ -19,7 +19,7 @@ export namespace HttpAssertQueryProgrammer {
 
   export const decompose = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
     init?: ts.Expression | undefined;
@@ -85,17 +85,17 @@ export namespace HttpAssertQueryProgrammer {
   };
 
   export const write = (props: IProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
       allowOptional: !!props.allowOptional,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/http/HttpFormDataProgrammer.ts

@@ -18,15 +18,16 @@ import { TransformerError } from "../../transformers/TransformerError";
 import { Atomic } from "../../typings/Atomic";
 
 import { Escaper } from "../../utils/Escaper";
+import { StringUtil } from "../../utils/StringUtil";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
 
 export namespace HttpFormDataProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -45,14 +46,15 @@ export namespace HttpFormDataProgrammer {
       type: props.type,
     });
     if (result.success === false)
-      throw TransformerError.from(`typia.http.${props.importer.method}`)(
-        result.errors,
-      );
+      throw TransformerError.from({
+        code: props.functor.method,
+        errors: result.errors,
+      });
 
     // DO TRANSFORM
     const object: MetadataObject = result.data.objects[0]!;
     const statements: ts.Statement[] = decode_object({
-      importer: props.importer,
+      context: props.context,
       object,
     });
     return {
@@ -91,16 +93,16 @@ export namespace HttpFormDataProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };
@@ -161,7 +163,7 @@ export namespace HttpFormDataProgrammer {
   };
 
   const decode_object = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
     object: MetadataObject;
   }): ts.Statement[] => {
     // const input: ts.Identifier = ts.factory.createIdentifier("input");
@@ -172,7 +174,7 @@ export namespace HttpFormDataProgrammer {
         value: ts.factory.createObjectLiteralExpression(
           props.object.properties.map((p) =>
             decode_regular_property({
-              importer: props.importer,
+              context: props.context,
               property: p,
             }),
           ),
@@ -186,7 +188,7 @@ export namespace HttpFormDataProgrammer {
   };
 
   const decode_regular_property = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
     property: MetadataProperty;
   }): ts.PropertyAssignment => {
     const key: string = props.property.key.constants[0]!.values[0]!
@@ -222,7 +224,7 @@ export namespace HttpFormDataProgrammer {
       Escaper.variable(key) ? key : ts.factory.createStringLiteral(key),
       isArray
         ? decode_array({
-            importer: props.importer,
+            context: props.context,
             metadata: value,
             input: ts.factory.createCallExpression(
               IdentifierFactory.access(
@@ -242,7 +244,7 @@ export namespace HttpFormDataProgrammer {
                   undefined,
                   undefined,
                   decode_value({
-                    importer: props.importer,
+                    context: props.context,
                     type,
                     coalesce: false,
                     input: ts.factory.createIdentifier("elem"),
@@ -252,7 +254,7 @@ export namespace HttpFormDataProgrammer {
             ),
           })
         : decode_value({
-            importer: props.importer,
+            context: props.context,
             type,
             coalesce: value.nullable === false && value.isRequired() === false,
             input: ts.factory.createCallExpression(
@@ -265,13 +267,15 @@ export namespace HttpFormDataProgrammer {
   };
 
   const decode_value = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
     type: Atomic.Literal | "blob" | "file";
     coalesce: boolean;
     input: ts.Expression;
   }) => {
     const call = ts.factory.createCallExpression(
-      props.importer.use(props.type),
+      props.context.importer.internal(
+        `httpFormDataRead${StringUtil.capitalize(props.type)}`,
+      ),
       undefined,
       [props.input],
     );
@@ -285,13 +289,13 @@ export namespace HttpFormDataProgrammer {
   };
 
   const decode_array = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
     metadata: Metadata;
     input: ts.Expression;
   }): ts.Expression =>
     props.metadata.nullable || props.metadata.isRequired() === false
       ? ts.factory.createCallExpression(
-          props.importer.use("array"),
+          props.context.importer.internal("httpFormDataReadArray"),
           undefined,
           [
             props.input,