typia 7.0.0-dev.20240918 → 7.0.0-dev.20240920

package/src/programmers/CheckerProgrammer.ts

@@ -65,8 +65,14 @@ export namespace CheckerProgrammer {
       };
     }
     export interface IJoiner {
-      object(input: ts.Expression, entries: IExpressionEntry[]): ts.Expression;
-      array(input: ts.Expression, arrow: ts.ArrowFunction): ts.Expression;
+      object(props: {
+        input: ts.Expression;
+        entries: IExpressionEntry[];
+      }): ts.Expression;
+      array(props: {
+        input: ts.Expression;
+        arrow: ts.ArrowFunction;
+      }): ts.Expression;
       tuple?: undefined | ((exprs: ts.Expression[]) => ts.Expression);
 
       failure(
@@ -303,10 +309,10 @@ export namespace CheckerProgrammer {
     (importer: FunctionImporter) =>
     (
       input: ts.Expression,
-      meta: Metadata,
+      metadata: Metadata,
       explore: IExplore,
     ): ts.Expression => {
-      if (meta.any) return config.success;
+      if (metadata.any) return config.success;
 
       const top: IBinary[] = [];
       const binaries: IBinary[] = [];
@@ -323,25 +329,29 @@ export namespace CheckerProgrammer {
       // CHECK OPTIONAL
       //----
       // @todo -> should be elaborated
-      const checkOptional: boolean = meta.empty() || meta.isUnionBucket();
+      const checkOptional: boolean =
+        metadata.empty() || metadata.isUnionBucket();
 
       // NULLABLE
-      if (checkOptional || meta.nullable)
-        (meta.nullable ? add : create_add(top)(input))(
-          meta.nullable,
+      if (checkOptional || metadata.nullable)
+        (metadata.nullable ? add : create_add(top)(input))(
+          metadata.nullable,
           ValueFactory.NULL(),
         );
 
       // UNDEFINDABLE
-      if (checkOptional || !meta.isRequired())
-        (meta.isRequired() ? create_add(top)(input) : add)(
-          !meta.isRequired(),
+      if (checkOptional || !metadata.isRequired())
+        (metadata.isRequired() ? create_add(top)(input) : add)(
+          !metadata.isRequired(),
           ValueFactory.UNDEFINED(),
         );
 
       // FUNCTIONAL
-      if (meta.functions.length)
-        if (OptionPredicator.functional(project.options) || meta.size() !== 1)
+      if (metadata.functions.length)
+        if (
+          OptionPredicator.functional(project.options) ||
+          metadata.size() !== 1
+        )
           add(
             true,
             ts.factory.createStringLiteral("function"),
@@ -357,8 +367,11 @@ export namespace CheckerProgrammer {
       // VALUES
       //----
       // CONSTANT VALUES
-      const constants: MetadataConstant[] = meta.constants.filter((c) =>
-        AtomicPredicator.constant(meta)(c.type),
+      const constants: MetadataConstant[] = metadata.constants.filter((c) =>
+        AtomicPredicator.constant({
+          metadata,
+          name: c.type,
+        }),
       );
       const constantLength: number = constants
         .map((c) => c.values.length)
@@ -401,12 +414,23 @@ export namespace CheckerProgrammer {
         );
       } else
         for (const c of constants)
-          if (AtomicPredicator.constant(meta)(c.type))
+          if (
+            AtomicPredicator.constant({
+              metadata,
+              name: c.type,
+            })
+          )
             for (const v of c.values) add(true, getConstantValue(v.value));
 
       // ATOMIC VALUES
-      for (const atom of meta.atomics)
-        if (AtomicPredicator.atomic(meta)(atom.type) === false) continue;
+      for (const atom of metadata.atomics)
+        if (
+          AtomicPredicator.atomic({
+            metadata,
+            name: atom.type,
+          }) === false
+        )
+          continue;
         else if (atom.type === "number")
           binaries.push({
             expression: config.atomist(explore)(
@@ -436,17 +460,17 @@ export namespace CheckerProgrammer {
           );
 
       // TEMPLATE LITERAL VALUES
-      if (meta.templates.length)
-        if (AtomicPredicator.template(meta))
+      if (metadata.templates.length)
+        if (AtomicPredicator.template(metadata))
           binaries.push({
             expression: config.atomist(explore)(
-              check_template(meta.templates)(input),
+              check_template(metadata.templates)(input),
             )(input),
             combined: false,
           });
 
       // NATIVE CLASSES
-      for (const native of meta.natives)
+      for (const native of metadata.natives)
         binaries.push({
           expression: check_native(native)(input),
           combined: false,
@@ -471,15 +495,15 @@ export namespace CheckerProgrammer {
           });
 
       // SETS
-      if (meta.sets.length) {
+      if (metadata.sets.length) {
         const install = prepare(
           check_native("Set")(input),
-          meta.sets.map((elem) => `Set<${elem.getName()}>`).join(" | "),
+          metadata.sets.map((elem) => `Set<${elem.getName()}>`).join(" | "),
         );
-        if (meta.sets.some((elem) => elem.any)) install(null);
+        if (metadata.sets.some((elem) => elem.any)) install(null);
         else
           install(
-            explore_sets(project)(config)(importer)(input, meta.sets, {
+            explore_sets(project)(config)(importer)(input, metadata.sets, {
               ...explore,
               from: "array",
             }),
@@ -487,18 +511,18 @@ export namespace CheckerProgrammer {
       }
 
       // MAPS
-      if (meta.maps.length) {
+      if (metadata.maps.length) {
         const install = prepare(
           check_native("Map")(input),
-          meta.maps
+          metadata.maps
             .map(({ key, value }) => `Map<${key}, ${value}>`)
             .join(" | "),
         );
-        if (meta.maps.some((elem) => elem.key.any && elem.value.any))
+        if (metadata.maps.some((elem) => elem.key.any && elem.value.any))
           install(null);
         else
           install(
-            explore_maps(project)(config)(importer)(input, meta.maps, {
+            explore_maps(project)(config)(importer)(input, metadata.maps, {
               ...explore,
               from: "array",
             }),
@@ -506,77 +530,94 @@ export namespace CheckerProgrammer {
       }
 
       // ARRAYS AND TUPLES
-      if (meta.tuples.length + meta.arrays.length > 0) {
+      if (metadata.tuples.length + metadata.arrays.length > 0) {
         const install = prepare(
           config.atomist(explore)({
             expected: [
-              ...meta.tuples.map((t) => t.type.name),
-              ...meta.arrays.map((a) => a.getName()),
+              ...metadata.tuples.map((t) => t.type.name),
+              ...metadata.arrays.map((a) => a.getName()),
             ].join(" | "),
             expression: ExpressionFactory.isArray(input),
             conditions: [],
           })(input),
-          [...meta.tuples, ...meta.arrays]
+          [...metadata.tuples, ...metadata.arrays]
             .map((elem) => elem.type.name)
             .join(" | "),
         );
-        if (meta.arrays.length === 0)
-          if (meta.tuples.length === 1)
+        if (metadata.arrays.length === 0)
+          if (metadata.tuples.length === 1)
             install(
-              decode_tuple(project)(config)(importer)(input, meta.tuples[0]!, {
-                ...explore,
-                from: "array",
-              }),
+              decode_tuple(project)(config)(importer)(
+                input,
+                metadata.tuples[0]!,
+                {
+                  ...explore,
+                  from: "array",
+                },
+              ),
             );
           // TUPLE ONLY
           else
             install(
-              explore_tuples(project)(config)(importer)(input, meta.tuples, {
-                ...explore,
-                from: "array",
-              }),
+              explore_tuples(project)(config)(importer)(
+                input,
+                metadata.tuples,
+                {
+                  ...explore,
+                  from: "array",
+                },
+              ),
             );
-        else if (meta.arrays.some((elem) => elem.type.value.any)) install(null);
-        else if (meta.tuples.length === 0)
-          if (meta.arrays.length === 1)
+        else if (metadata.arrays.some((elem) => elem.type.value.any))
+          install(null);
+        else if (metadata.tuples.length === 0)
+          if (metadata.arrays.length === 1)
             // ARRAY ONLY
             install(
-              decode_array(project)(config)(importer)(input, meta.arrays[0]!, {
-                ...explore,
-                from: "array",
-              }),
+              decode_array(project)(config)(importer)(
+                input,
+                metadata.arrays[0]!,
+                {
+                  ...explore,
+                  from: "array",
+                },
+              ),
             );
           else
             install(
-              explore_arrays(project)(config)(importer)(input, meta.arrays, {
-                ...explore,
-                from: "array",
-              }),
+              explore_arrays(project)(config)(importer)(
+                input,
+                metadata.arrays,
+                {
+                  ...explore,
+                  from: "array",
+                },
+              ),
             );
         else
           install(
             explore_arrays_and_tuples(project)(config)(importer)(
               input,
-              [...meta.tuples, ...meta.arrays],
+              [...metadata.tuples, ...metadata.arrays],
               explore,
             ),
           );
       }
 
       // OBJECT
-      if (meta.objects.length > 0)
+      if (metadata.objects.length > 0)
         prepare(
           ExpressionFactory.isObject({
             checkNull: true,
-            checkArray: meta.objects.some((obj) =>
+            checkArray: metadata.objects.some((obj) =>
               obj.properties.every(
                 (prop) => !prop.key.isSoleLiteral() || !prop.value.isRequired(),
               ),
             ),
           })(input),
-          meta.objects.map((obj) => obj.name).join(" | "),
+          metadata.objects.map((obj) => obj.name).join(" | "),
         )(
-          explore_objects(config)(importer)(input, meta, {
+          explore_objects(config)(importer)(input, metadata, {
             ...explore,
             from: "object",
           }),
@@ -604,7 +645,7 @@ export namespace CheckerProgrammer {
                   expression,
                   combined: expression !== pre,
                 })),
-                meta.getName(),
+                metadata.getName(),
               ),
             )(instances[0]!),
           );
@@ -613,31 +654,31 @@ export namespace CheckerProgrammer {
             expression: config.combiner(explore)("or")(
               input,
               instances.map(transformer(ts.factory.createLogicalAnd)),
-              meta.getName(),
+              metadata.getName(),
             ),
             combined: true,
           });
       }
 
       // ESCAPED CASE
-      if (meta.escaped !== null)
+      if (metadata.escaped !== null)
         binaries.push({
           combined: false,
           expression:
-            meta.escaped.original.size() === 1 &&
-            meta.escaped.original.natives.length === 1
-              ? check_native(meta.escaped.original.natives[0]!)(input)
+            metadata.escaped.original.size() === 1 &&
+            metadata.escaped.original.natives.length === 1
+              ? check_native(metadata.escaped.original.natives[0]!)(input)
               : ts.factory.createLogicalAnd(
                   decode(project)(config)(importer)(
                     input,
-                    meta.escaped.original,
+                    metadata.escaped.original,
                     explore,
                   ),
                   ts.factory.createLogicalAnd(
                     IsProgrammer.decode_to_json(false)(input),
                     decode_escaped(project)(config)(importer)(
                       input,
-                      meta.escaped.returns,
+                      metadata.escaped.returns,
                       explore,
                     ),
                   ),
@@ -656,15 +697,15 @@ export namespace CheckerProgrammer {
                 expression: config.combiner(explore)("or")(
                   input,
                   binaries,
-                  meta.getName(),
+                  metadata.getName(),
                 ),
                 combined: true,
               },
             ],
-            meta.getName(),
+            metadata.getName(),
           )
         : binaries.length
-          ? config.combiner(explore)("or")(input, binaries, meta.getName())
+          ? config.combiner(explore)("or")(input, binaries, metadata.getName())
           : config.success;
     };
 

package/src/programmers/FeatureProgrammer.ts

@@ -86,11 +86,11 @@ export namespace FeatureProgrammer {
       /**
        * Joiner of expressions from properties.
        */
-      joiner(
-        input: ts.Expression,
-        entries: IExpressionEntry<Output>[],
-        parent: MetadataObject,
-      ): ts.ConciseBody;
+      joiner(props: {
+        entries: IExpressionEntry<Output>[];
+        input?: ts.Expression;
+        object?: MetadataObject;
+      }): ts.ConciseBody;
 
       /**
        * Union type specificator.
@@ -356,29 +356,27 @@ export namespace FeatureProgrammer {
     (config: IConfig) =>
     (importer: FunctionImporter) =>
     (collection: MetadataCollection) =>
-      collection
-        .objects()
-        .map((obj) =>
-          StatementFactory.constant(
-            `${config.prefix}o${obj.index}`,
-            ts.factory.createArrowFunction(
-              undefined,
-              undefined,
-              parameterDeclarations(config)(TypeFactory.keyword("any"))(
-                ValueFactory.INPUT(),
-              ),
-              config.objector.type ?? TypeFactory.keyword("any"),
-              undefined,
-              config.objector.joiner(
+      collection.objects().map((object) =>
+        StatementFactory.constant(
+          `${config.prefix}o${object.index}`,
+          ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            parameterDeclarations(config)(TypeFactory.keyword("any"))(
+              ValueFactory.INPUT(),
+            ),
+            config.objector.type ?? TypeFactory.keyword("any"),
+            undefined,
+            config.objector.joiner({
+              input: ts.factory.createIdentifier("input"),
+              entries: feature_object_entries(config)(importer)(object)(
                 ts.factory.createIdentifier("input"),
-                feature_object_entries(config)(importer)(obj)(
-                  ts.factory.createIdentifier("input"),
-                ),
-                obj,
               ),
-            ),
+              object,
+            }),
           ),
-        );
+        ),
+      );
 
   export const write_union_functions =
     (config: IConfig) => (collection: MetadataCollection) =>
@@ -420,10 +418,10 @@ export namespace FeatureProgrammer {
     (config: Pick<IConfig, "trace" | "path" | "decoder" | "prefix">) =>
     (importer: FunctionImporter) =>
     (
-      combiner: (
-        input: ts.Expression,
-        arrow: ts.ArrowFunction,
-      ) => ts.Expression,
+      combiner: (props: {
+        input: ts.Expression;
+        arrow: ts.ArrowFunction;
+      }) => ts.Expression,
     ) => {
       const rand: string = importer.increment().toString();
       const tail =
@@ -457,7 +455,10 @@ export namespace FeatureProgrammer {
             postfix: index(explore.start ?? null)(explore.postfix)(rand),
           }),
         );
-        return combiner(input, arrow);
+        return combiner({
+          input,
+          arrow,
+        });
       };
     };
 

package/src/programmers/IsProgrammer.ts

@@ -72,11 +72,11 @@ export namespace IsProgrammer {
             positive: ts.factory.createTrue(),
             superfluous: () => ts.factory.createFalse(),
           })(project)(importer),
-        array: (input, arrow) =>
+        array: (props) =>
           ts.factory.createCallExpression(
-            IdentifierFactory.access(input)("every"),
+            IdentifierFactory.access(props.input)("every"),
             undefined,
-            [arrow],
+            [props.arrow],
           ),
         failure: () => ts.factory.createFalse(),
       },
@@ -87,10 +87,10 @@ export namespace IsProgrammer {
     export interface IOptions {
       numeric: boolean;
       undefined: boolean;
-      object: (
-        input: ts.Expression,
-        entries: IExpressionEntry<ts.Expression>[],
-      ) => ts.Expression;
+      object: (props: {
+        input: ts.Expression;
+        entries: IExpressionEntry<ts.Expression>[];
+      }) => ts.Expression;
     }
   }
 

package/src/programmers/ValidateProgrammer.ts

@@ -320,12 +320,12 @@ const joiner =
   (project: ITypiaContext) =>
   (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
     object: validate_object(equals)(project)(importer),
-    array: (input, arrow) =>
+    array: (props) =>
       check_everything(
         ts.factory.createCallExpression(
-          IdentifierFactory.access(input)("map"),
+          IdentifierFactory.access(props.input)("map"),
           undefined,
-          [arrow],
+          [props.arrow],
         ),
       ),
     failure: (value, expected, explore) =>

package/src/programmers/helpers/AtomicPredicator.ts

@@ -5,20 +5,31 @@ import { Atomic } from "../../typings/Atomic";
 import { ArrayUtil } from "../../utils/ArrayUtil";
 
 export namespace AtomicPredicator {
-  export const constant =
-    (meta: Metadata) =>
-    (name: Atomic.Literal): boolean =>
-      !ArrayUtil.has(meta.natives, (native) => native.toLowerCase() === name);
+  export const constant = (props: {
+    metadata: Metadata;
+    name: Atomic.Literal;
+  }): boolean =>
+    !ArrayUtil.has(
+      props.metadata.natives,
+      (native) => native.toLowerCase() === props.name,
+    );
 
-  export const atomic =
-    (meta: Metadata) =>
-    (name: Atomic.Literal): boolean =>
-      !ArrayUtil.has(meta.natives, (native) => native.toLowerCase() === name);
+  export const atomic = (props: {
+    metadata: Metadata;
+    name: Atomic.Literal;
+  }): boolean =>
+    !ArrayUtil.has(
+      props.metadata.natives,
+      (native) => native.toLowerCase() === props.name,
+    );
 
   export const native = (name: string) => LIKE.has(name.toLowerCase());
 
-  export const template = (meta: Metadata): boolean =>
-    !ArrayUtil.has(meta.natives, (native) => native.toLowerCase() === "string");
+  export const template = (metadata: Metadata): boolean =>
+    !ArrayUtil.has(
+      metadata.natives,
+      (native) => native.toLowerCase() === "string",
+    );
 }
 
 const LIKE = new Set(["boolean", "bigint", "number", "string"]);

package/src/programmers/helpers/CloneJoiner.ts

@@ -10,14 +10,14 @@ import { metadata_to_pattern } from "../internal/metadata_to_pattern";
 import { IExpressionEntry } from "./IExpressionEntry";
 
 export namespace CloneJoiner {
-  export const object = (
-    input: ts.Expression,
-    entries: IExpressionEntry<ts.Expression>[],
-  ): ts.ConciseBody => {
-    if (entries.length === 0) return ts.factory.createIdentifier("{}");
+  export const object = (props: {
+    input: ts.Expression;
+    entries: IExpressionEntry<ts.Expression>[];
+  }): ts.ConciseBody => {
+    if (props.entries.length === 0) return ts.factory.createIdentifier("{}");
 
-    const regular = entries.filter((e) => e.key.isSoleLiteral());
-    const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
+    const regular = props.entries.filter((e) => e.key.isSoleLiteral());
+    const dynamic = props.entries.filter((e) => !e.key.isSoleLiteral());
     const literal = ts.factory.createObjectLiteralExpression(
       regular.map((entry) => {
         const str: string = entry.key.getSoleLiteral()!;
@@ -98,7 +98,7 @@ export namespace CloneJoiner {
         ts.factory.createCallExpression(
           ts.factory.createIdentifier("Object.entries"),
           undefined,
-          [input],
+          [props.input],
         ),
         ts.factory.createBlock(statements),
       ),
@@ -106,25 +106,28 @@ export namespace CloneJoiner {
     ]);
   };
 
-  export const tuple = (
-    children: ts.Expression[],
-    rest: ts.Expression | null,
-  ): ts.Expression => {
+  export const tuple = (props: {
+    elements: ts.Expression[];
+    rest: ts.Expression | null;
+  }): ts.Expression => {
     return ts.factory.createAsExpression(
       ts.factory.createArrayLiteralExpression(
-        rest === null
-          ? children
-          : [...children, ts.factory.createSpreadElement(rest)],
+        props.rest === null
+          ? props.elements
+          : [...props.elements, ts.factory.createSpreadElement(props.rest)],
         true,
       ),
       TypeFactory.keyword("any"),
     );
   };
 
-  export const array = (input: ts.Expression, arrow: ts.Expression) =>
+  export const array = (props: {
+    input: ts.Expression;
+    arrow: ts.Expression;
+  }) =>
     ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(input, "map"),
+      ts.factory.createPropertyAccessExpression(props.input, "map"),
       undefined,
-      [arrow],
+      [props.arrow],
     );
 }

package/src/programmers/helpers/HttpMetadataUtil.ts

@@ -2,20 +2,20 @@ import { Metadata } from "../../schemas/metadata/Metadata";
 
 export namespace HttpMetadataUtil {
   export const atomics = (
-    meta: Metadata,
+    metadata: Metadata,
   ): Set<"boolean" | "bigint" | "number" | "string"> =>
     new Set([
-      ...meta.atomics.map((a) => a.type),
-      ...meta.constants.map((c) => c.type),
-      ...(meta.templates.length ? (["string"] as const) : []),
+      ...metadata.atomics.map((a) => a.type),
+      ...metadata.constants.map((c) => c.type),
+      ...(metadata.templates.length ? (["string"] as const) : []),
     ]);
 
-  export const isUnion = (meta: Metadata): boolean =>
-    atomics(meta).size +
-      meta.arrays.length +
-      meta.tuples.length +
-      meta.natives.length +
-      meta.maps.length +
-      meta.objects.length >
+  export const isUnion = (metadata: Metadata): boolean =>
+    atomics(metadata).size +
+      metadata.arrays.length +
+      metadata.tuples.length +
+      metadata.natives.length +
+      metadata.maps.length +
+      metadata.objects.length >
     1;
 }