typia 7.0.0-dev.20240916 → 7.0.0-dev.20240919

package/src/programmers/internal/check_object.ts

@@ -1,61 +1,64 @@
-import ts from "typescript";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { FunctionImporter } from "../helpers/FunctionImporter";
-import { IExpressionEntry } from "../helpers/IExpressionEntry";
-import { check_dynamic_properties } from "./check_dynamic_properties";
-import { check_everything } from "./check_everything";
-
-/**
- * @internal
- */
-export const check_object =
-  (props: check_object.IProps) =>
-  (project: ITypiaContext) =>
-  (importer: FunctionImporter) =>
-  (input: ts.Expression, entries: IExpressionEntry<ts.Expression>[]) => {
-    // PREPARE ASSETS
-    const regular = entries.filter((entry) => entry.key.isSoleLiteral());
-    const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
-    const flags: ts.Expression[] = regular.map((entry) => entry.expression);
-
-    // REGULAR WITHOUT DYNAMIC PROPERTIES
-    if (props.equals === false && dynamic.length === 0)
-      return regular.length === 0 ? props.positive : reduce(props)(flags);
-
-    // CHECK DYNAMIC PROPERTIES
-    flags.push(
-      check_dynamic_properties(props)(project)(importer)(
-        input,
-        regular,
-        dynamic,
-      ),
-    );
-    return reduce(props)(flags);
-  };
-
-/**
- * @internal
- */
-export namespace check_object {
-  export interface IProps {
-    equals: boolean;
-    assert: boolean;
-    undefined: boolean;
-    halt?: undefined | ((exp: ts.Expression) => ts.Expression);
-    reduce: (a: ts.Expression, b: ts.Expression) => ts.Expression;
-    positive: ts.Expression;
-    superfluous: (value: ts.Expression) => ts.Expression;
-    entries?: undefined | ts.Identifier;
-  }
-}
-
-/**
- * @internal
- */
-const reduce =
-  (props: check_object.IProps) => (expressions: ts.Expression[]) =>
-    props.assert
-      ? expressions.reduce(props.reduce)
-      : check_everything(ts.factory.createArrayLiteralExpression(expressions));
+import ts from "typescript";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { FunctionImporter } from "../helpers/FunctionImporter";
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+import { check_dynamic_properties } from "./check_dynamic_properties";
+import { check_everything } from "./check_everything";
+
+/**
+ * @internal
+ */
+export const check_object =
+  (config: check_object.IProps) =>
+  (project: ITypiaContext) =>
+  (importer: FunctionImporter) =>
+  (props: {
+    input: ts.Expression;
+    entries: IExpressionEntry<ts.Expression>[];
+  }) => {
+    // PREPARE ASSETS
+    const regular = props.entries.filter((entry) => entry.key.isSoleLiteral());
+    const dynamic = props.entries.filter((entry) => !entry.key.isSoleLiteral());
+    const flags: ts.Expression[] = regular.map((entry) => entry.expression);
+
+    // REGULAR WITHOUT DYNAMIC PROPERTIES
+    if (config.equals === false && dynamic.length === 0)
+      return regular.length === 0 ? config.positive : reduce(config)(flags);
+
+    // CHECK DYNAMIC PROPERTIES
+    flags.push(
+      check_dynamic_properties(config)(project)(importer)(
+        props.input,
+        regular,
+        dynamic,
+      ),
+    );
+    return reduce(config)(flags);
+  };
+
+/**
+ * @internal
+ */
+export namespace check_object {
+  export interface IProps {
+    equals: boolean;
+    assert: boolean;
+    undefined: boolean;
+    halt?: undefined | ((exp: ts.Expression) => ts.Expression);
+    reduce: (a: ts.Expression, b: ts.Expression) => ts.Expression;
+    positive: ts.Expression;
+    superfluous: (value: ts.Expression) => ts.Expression;
+    entries?: undefined | ts.Identifier;
+  }
+}
+
+/**
+ * @internal
+ */
+const reduce =
+  (props: check_object.IProps) => (expressions: ts.Expression[]) =>
+    props.assert
+      ? expressions.reduce(props.reduce)
+      : check_everything(ts.factory.createArrayLiteralExpression(expressions));

package/src/programmers/internal/check_string.ts

@@ -1,48 +1,48 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-
-/**
- * @internal
- */
-export const check_string =
-  (project: ITypiaContext) =>
-  (atomic: MetadataAtomic) =>
-  (input: ts.Expression): ICheckEntry => {
-    const conditions: ICheckEntry.ICondition[][] =
-      check_string_type_tags(project)(atomic)(input);
-    return {
-      expected: atomic.getName(),
-      expression: ts.factory.createStrictEquality(
-        ts.factory.createStringLiteral("string"),
-        ts.factory.createTypeOfExpression(input),
-      ),
-      conditions,
-    };
-  };
-
-/**
- * @internal
- */
-const check_string_type_tags =
-  (project: ITypiaContext) =>
-  (atomic: MetadataAtomic) =>
-  (input: ts.Expression): ICheckEntry.ICondition[][] =>
-    atomic.tags
-      .map((row) => row.filter((tag) => !!tag.validate))
-      .filter((row) => !!row.length)
-      .map((row) =>
-        row.map((tag) => ({
-          expected: `string & ${tag.name}`,
-          expression: (
-            tag.predicate ??
-            ExpressionFactory.transpile(project.transformer)(tag.validate!)
-          )(input),
-        })),
-      );
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+
+/**
+ * @internal
+ */
+export const check_string =
+  (project: ITypiaContext) =>
+  (atomic: MetadataAtomic) =>
+  (input: ts.Expression): ICheckEntry => {
+    const conditions: ICheckEntry.ICondition[][] =
+      check_string_type_tags(project)(atomic)(input);
+    return {
+      expected: atomic.getName(),
+      expression: ts.factory.createStrictEquality(
+        ts.factory.createStringLiteral("string"),
+        ts.factory.createTypeOfExpression(input),
+      ),
+      conditions,
+    };
+  };
+
+/**
+ * @internal
+ */
+const check_string_type_tags =
+  (project: ITypiaContext) =>
+  (atomic: MetadataAtomic) =>
+  (input: ts.Expression): ICheckEntry.ICondition[][] =>
+    atomic.tags
+      .map((row) => row.filter((tag) => !!tag.validate))
+      .filter((row) => !!row.length)
+      .map((row) =>
+        row.map((tag) => ({
+          expected: `string & ${tag.name}`,
+          expression: (
+            tag.predicate ??
+            ExpressionFactory.transpile(project.transformer)(tag.validate!)
+          )(input),
+        })),
+      );

package/src/programmers/internal/llm_schema_array.ts

@@ -9,8 +9,8 @@ import { llm_schema_station } from "./llm_schema_station";
  * @internal
  */
 export const llm_schema_array = (array: MetadataArray): ILlmSchema.IArray[] =>
-  application_plugin(
-    {
+  application_plugin({
+    schema: {
       type: "array",
       items: llm_schema_station({
         metadata: array.type.value,
@@ -18,5 +18,5 @@ export const llm_schema_array = (array: MetadataArray): ILlmSchema.IArray[] =>
         attribute: {},
       }),
     },
-    array.tags,
-  );
+    tags: array.tags,
+  });

package/src/programmers/internal/llm_schema_station.ts

@@ -61,7 +61,12 @@ export const llm_schema_station = (props: {
   )
     application_templates<"3.0">(props.metadata).map(insert);
   for (const constant of props.metadata.constants)
-    if (AtomicPredicator.constant(props.metadata)(constant.type) === false)
+    if (
+      AtomicPredicator.constant({
+        metadata: props.metadata,
+        name: constant.type,
+      }) === false
+    )
       continue;
     else insert(application_v30_constant(constant));
   for (const a of props.metadata.atomics)

package/src/programmers/json/JsonApplicationProgrammer.ts

@@ -43,7 +43,12 @@ export namespace JsonApplicationProgrammer {
   const v30 = (metadatas: Array<Metadata>): IJsonApplication<"3.0"> => {
     const components: OpenApiV3.IComponents = {};
     const generator = (meta: Metadata): OpenApiV3.IJsonSchema | null =>
-      application_v30_schema(true)(components)({})(meta);
+      application_v30_schema({
+        blockNever: true,
+        components,
+        attribute: {},
+        metadata: meta,
+      });
     return {
       version: "3.0",
       components,
@@ -64,7 +69,12 @@ export namespace JsonApplicationProgrammer {
       schemas: {},
     };
     const generator = (meta: Metadata): OpenApi.IJsonSchema | null =>
-      application_v31_schema(true)(components)({})(meta);
+      application_v31_schema({
+        blockNever: true,
+        components,
+        attribute: {},
+        metadata: meta,
+      });
     return {
       version: "3.1",
       components,

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -164,19 +164,19 @@ export namespace JsonStringifyProgrammer {
     (importer: FunctionImporter) =>
     (
       input: ts.Expression,
-      meta: Metadata,
+      metadata: Metadata,
       explore: FeatureProgrammer.IExplore,
     ): ts.Expression => {
       // ANY TYPE
-      if (meta.any === true)
+      if (metadata.any === true)
         return wrap_required(
           input,
-          meta,
+          metadata,
           explore,
         )(
           wrap_functional(
             input,
-            meta,
+            metadata,
             explore,
           )(
             ts.factory.createCallExpression(
@@ -188,12 +188,12 @@ export namespace JsonStringifyProgrammer {
         );
 
       // ONLY NULL OR UNDEFINED
-      const size: number = meta.size();
+      const size: number = metadata.size();
       if (
         size === 0 &&
-        (meta.isRequired() === false || meta.nullable === true)
+        (metadata.isRequired() === false || metadata.nullable === true)
       ) {
-        if (meta.isRequired() === false && meta.nullable === true)
+        if (metadata.isRequired() === false && metadata.nullable === true)
           return explore.from === "array"
             ? ts.factory.createStringLiteral("null")
             : ts.factory.createConditionalExpression(
@@ -203,7 +203,7 @@ export namespace JsonStringifyProgrammer {
                 undefined,
                 ts.factory.createIdentifier("undefined"),
               );
-        else if (meta.isRequired() === false)
+        else if (metadata.isRequired() === false)
           return explore.from === "array"
             ? ts.factory.createStringLiteral("null")
             : ts.factory.createIdentifier("undefined");
@@ -216,22 +216,22 @@ export namespace JsonStringifyProgrammer {
       const unions: IUnion[] = [];
 
       // toJSON() METHOD
-      if (meta.escaped !== null)
+      if (metadata.escaped !== null)
         unions.push({
           type: "resolved",
           is:
-            meta.escaped.original.size() === 1 &&
-            meta.escaped.original.natives[0] === "Date"
+            metadata.escaped.original.size() === 1 &&
+            metadata.escaped.original.natives[0] === "Date"
               ? () => check_native("Date")(input)
               : () => IsProgrammer.decode_to_json(false)(input),
           value: () =>
             decode_to_json(project)(config)(importer)(
               input,
-              meta.escaped!.returns,
+              metadata.escaped!.returns,
               explore,
             ),
         });
-      else if (meta.functions.length)
+      else if (metadata.functions.length)
         unions.push({
           type: "functional",
           is: () => IsProgrammer.decode_functional(input),
@@ -240,10 +240,10 @@ export namespace JsonStringifyProgrammer {
 
       // TEMPLATES
       if (
-        meta.templates.length ||
-        ArrayUtil.has(meta.constants, (c) => c.type === "string")
+        metadata.templates.length ||
+        ArrayUtil.has(metadata.constants, (c) => c.type === "string")
       )
-        if (AtomicPredicator.template(meta)) {
+        if (AtomicPredicator.template(metadata)) {
           const partial = Metadata.initialize();
           partial.atomics.push(
             MetadataAtomic.create({ type: "string", tags: [] }),
@@ -258,8 +258,14 @@ export namespace JsonStringifyProgrammer {
         }
 
       // CONSTANTS
-      for (const constant of meta.constants)
-        if (AtomicPredicator.constant(meta)(constant.type) === false) continue;
+      for (const constant of metadata.constants)
+        if (
+          AtomicPredicator.constant({
+            metadata,
+            name: constant.type,
+          }) === false
+        )
+          continue;
         else if (constant.type !== "string")
           unions.push({
             type: "atomic",
@@ -281,7 +287,7 @@ export namespace JsonStringifyProgrammer {
             value: () =>
               decode_atomic(project)(importer)(input, constant.type, explore),
           });
-        else if (meta.templates.length === 0)
+        else if (metadata.templates.length === 0)
           unions.push({
             type: "const string",
             is: () =>
@@ -308,8 +314,13 @@ export namespace JsonStringifyProgrammer {
           });
 
       /// ATOMICS
-      for (const a of meta.atomics)
-        if (AtomicPredicator.atomic(meta)(a.type))
+      for (const a of metadata.atomics)
+        if (
+          AtomicPredicator.atomic({
+            metadata,
+            name: a.type,
+          })
+        )
           unions.push({
             type: "atomic",
             is: () =>
@@ -327,7 +338,7 @@ export namespace JsonStringifyProgrammer {
           });
 
       // TUPLES
-      for (const tuple of meta.tuples)
+      for (const tuple of metadata.tuples)
         unions.push({
           type: "tuple",
           is: () =>
@@ -345,15 +356,15 @@ export namespace JsonStringifyProgrammer {
         });
 
       // ARRAYS
-      if (meta.arrays.length) {
+      if (metadata.arrays.length) {
         const value: () => ts.Expression =
-          meta.arrays.length === 1
+          metadata.arrays.length === 1
             ? () =>
-                decode_array(config)(importer)(input, meta.arrays[0]!, {
+                decode_array(config)(importer)(input, metadata.arrays[0]!, {
                   ...explore,
                   from: "array",
                 })
-            : meta.arrays.some((elem) => elem.type.value.any)
+            : metadata.arrays.some((elem) => elem.type.value.any)
               ? () =>
                   ts.factory.createCallExpression(
                     ts.factory.createIdentifier("JSON.stringify"),
@@ -363,7 +374,7 @@ export namespace JsonStringifyProgrammer {
               : () =>
                   explore_arrays(project)(config)(importer)(
                     input,
-                    meta.arrays,
+                    metadata.arrays,
                     {
                       ...explore,
                       from: "array",
@@ -378,8 +389,8 @@ export namespace JsonStringifyProgrammer {
       }
 
       // BUILT-IN CLASSES
-      if (meta.natives.length)
-        for (const native of meta.natives)
+      if (metadata.natives.length)
+        for (const native of metadata.natives)
           unions.push({
             type: "object",
             is: () => check_native(native)(input),
@@ -394,7 +405,7 @@ export namespace JsonStringifyProgrammer {
           });
 
       // SETS
-      if (meta.sets.length)
+      if (metadata.sets.length)
         unions.push({
           type: "object",
           is: () => ExpressionFactory.isInstanceOf("Set")(input),
@@ -402,7 +413,7 @@ export namespace JsonStringifyProgrammer {
         });
 
       // MAPS
-      if (meta.maps.length)
+      if (metadata.maps.length)
         unions.push({
           type: "object",
           is: () => ExpressionFactory.isInstanceOf("Map")(input),
@@ -410,13 +421,13 @@ export namespace JsonStringifyProgrammer {
         });
 
       // OBJECTS
-      if (meta.objects.length)
+      if (metadata.objects.length)
         unions.push({
           type: "object",
           is: () =>
             ExpressionFactory.isObject({
               checkNull: true,
-              checkArray: meta.objects.some((obj) =>
+              checkArray: metadata.objects.some((obj) =>
                 obj.properties.every(
                   (prop) =>
                     !prop.key.isSoleLiteral() || !prop.value.isRequired(),
@@ -424,7 +435,7 @@ export namespace JsonStringifyProgrammer {
               ),
             })(input),
           value: () =>
-            explore_objects(config)(importer)(input, meta, {
+            explore_objects(config)(importer)(input, metadata, {
               ...explore,
               from: "object",
             }),
@@ -435,7 +446,11 @@ export namespace JsonStringifyProgrammer {
       //----
       // CHECK NULL AND UNDEFINED
       const wrapper = (output: ts.Expression) =>
-        wrap_required(input, meta, explore)(wrap_nullable(input, meta)(output));
+        wrap_required(
+          input,
+          metadata,
+          explore,
+        )(wrap_nullable(input, metadata)(output));
 
       // DIRECT RETURN
       if (unions.length === 0)
@@ -455,7 +470,7 @@ export namespace JsonStringifyProgrammer {
             [],
             undefined,
             undefined,
-            iterate(importer, input, unions, meta.getName()),
+            iterate(importer, input, unions, metadata.getName()),
           ),
           undefined,
           undefined,
@@ -541,7 +556,7 @@ export namespace JsonStringifyProgrammer {
       tuple: MetadataTupleType,
       explore: FeatureProgrammer.IExplore,
     ): ts.Expression => {
-      const children: ts.Expression[] = tuple.elements
+      const elements: ts.Expression[] = tuple.elements
         .filter((elem) => elem.rest === null)
         .map((elem, index) =>
           decode(project)(config)(importer)(
@@ -579,7 +594,10 @@ export namespace JsonStringifyProgrammer {
           [code],
         );
       })();
-      return StringifyJoiner.tuple(children, rest);
+      return StringifyJoiner.tuple({
+        elements,
+        rest,
+      });
     };
 
   const decode_atomic =
@@ -871,10 +889,12 @@ export namespace JsonStringifyProgrammer {
 
   const initializer: FeatureProgrammer.IConfig["initializer"] =
     (project) => (importer) => (type) =>
-      JsonMetadataFactory.analyze(`typia.json.${importer.method}`)(
-        project.checker,
-        project.transformer,
-      )(type);
+      JsonMetadataFactory.analyze({
+        method: `typia.json.${importer.method}`,
+        checker: project.checker,
+        transformer: project.transformer,
+        type,
+      });
 
   const create_throw_error =
     (importer: FunctionImporter) =>

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -375,7 +375,7 @@ export namespace MiscCloneProgrammer {
       tuple: MetadataTupleType,
       explore: FeatureProgrammer.IExplore,
     ): ts.Expression => {
-      const children: ts.Expression[] = tuple.elements
+      const elements: ts.Expression[] = tuple.elements
         .filter((m) => m.rest === null)
         .map((elem, index) =>
           decode(project)(config)(importer)(
@@ -410,7 +410,10 @@ export namespace MiscCloneProgrammer {
           },
         );
       })();
-      return CloneJoiner.tuple(children, rest);
+      return CloneJoiner.tuple({
+        elements,
+        rest,
+      });
     };
 
   /* -----------------------------------------------------------
@@ -722,22 +725,25 @@ export namespace MiscCloneProgrammer {
   const initializer: FeatureProgrammer.IConfig["initializer"] =
     (project) => (importer) => (type) => {
       const collection = new MetadataCollection();
-      const result = MetadataFactory.analyze(
-        project.checker,
-        project.transformer,
-      )({
-        escape: false,
-        constant: true,
-        absorb: true,
-        validate: (meta) => {
-          const output: string[] = [];
-          if (meta.natives.some((n) => n === "WeakSet"))
-            output.push("unable to clone WeakSet");
-          else if (meta.natives.some((n) => n === "WeakMap"))
-            output.push("unable to clone WeakMap");
-          return output;
+      const result = MetadataFactory.analyze({
+        checker: project.checker,
+        transformer: project.transformer,
+        options: {
+          escape: false,
+          constant: true,
+          absorb: true,
+          validate: (meta) => {
+            const output: string[] = [];
+            if (meta.natives.some((n) => n === "WeakSet"))
+              output.push("unable to clone WeakSet");
+            else if (meta.natives.some((n) => n === "WeakMap"))
+              output.push("unable to clone WeakMap");
+            return output;
+          },
         },
-      })(collection)(type);
+        collection,
+        type,
+      });
       if (result.success === false)
         throw TransformerError.from(`typia.misc.${importer.method}`)(
           result.errors,