typia 7.0.0-dev.20241012 → 7.0.0-dev.20241019

package/src/programmers/internal/llm_schema_object.ts

@@ -4,11 +4,12 @@ import { CommentFactory } from "../../factories/CommentFactory";
 
 import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
 import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 
 import { PatternUtil } from "../../utils/PatternUtil";
 
 import { application_description } from "./application_description";
+import { application_plugin } from "./application_plugin";
 import { llm_schema_station } from "./llm_schema_station";
 import { metadata_to_pattern } from "./metadata_to_pattern";
 
@@ -16,9 +17,9 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
  * @internal
  */
 export const llm_schema_object = (props: {
-  object: MetadataObjectType;
+  object: MetadataObject;
   nullable: boolean;
-}): ILlmSchema.IObject => {
+}): ILlmSchema.IObject[] => {
   // ITERATE PROPERTIES
   const properties: Record<string, any> = {};
   const extraMeta: ISuperfluous = {
@@ -27,7 +28,7 @@ export const llm_schema_object = (props: {
   };
   const required: string[] = [];
 
-  for (const property of props.object.properties) {
+  for (const property of props.object.type.properties) {
     if (
       // FUNCTIONAL TYPE
       property.value.functions.length &&
@@ -82,20 +83,22 @@ export const llm_schema_object = (props: {
     }
   }
 
-  return {
-    type: "object",
-    properties,
-    nullable: props.nullable,
-    required: required.length ? required : undefined,
-    title: (() => {
-      const info: IJsDocTagInfo | undefined = props.object.jsDocTags.find(
-        (tag) => tag.name === "title",
-      );
-      return info?.text?.length ? CommentFactory.merge(info.text) : undefined;
-    })(),
-    description: application_description(props.object),
-    additionalProperties: join(extraMeta),
-  };
+  return application_plugin({
+    schema: {
+      type: "object",
+      properties,
+      nullable: props.nullable,
+      required: required.length ? required : undefined,
+      title: (() => {
+        const info: IJsDocTagInfo | undefined =
+          props.object.type.jsDocTags.find((tag) => tag.name === "title");
+        return info?.text?.length ? CommentFactory.merge(info.text) : undefined;
+      })(),
+      description: application_description(props.object.type),
+      additionalProperties: join(extraMeta),
+    },
+    tags: props.object.tags,
+  });
 };
 
 /**

package/src/programmers/internal/llm_schema_station.ts

@@ -99,8 +99,8 @@ export const llm_schema_station = (props: {
 
   // NATIVES
   for (const native of props.metadata.natives)
-    if (AtomicPredicator.native(native)) {
-      const type: string = native.toLowerCase();
+    if (AtomicPredicator.native(native.name)) {
+      const type: string = native.name.toLowerCase();
       if (props.metadata.atomics.some((a) => a.type === type)) continue;
       else if (type === "boolean")
         insert(
@@ -138,7 +138,7 @@ export const llm_schema_station = (props: {
             }),
           )[0]!,
         );
-    } else insert(llm_schema_native(native));
+    } else insert(llm_schema_native(native.name));
   if (props.metadata.sets.length) insert(llm_schema_native("Set"));
   if (props.metadata.maps.length) insert(llm_schema_native("Map"));
 
@@ -149,16 +149,14 @@ export const llm_schema_station = (props: {
         "Error on LlmSchemaProgrammer.write(): LLM schema does not allow recursive object type.",
       );
     else
-      insert(
-        llm_schema_object({
-          object: object.type,
-          nullable: props.metadata.nullable,
-        }),
-      );
+      llm_schema_object({
+        object,
+        nullable: props.metadata.nullable,
+      }).forEach(insert);
 
   // ALIASES
   for (const alias of props.metadata.aliases)
-    if (alias.recursive)
+    if (alias.type.recursive)
       throw new Error(
         "Error on LlmSchemaProgrammer.write(): LLM schema does not allow recursive alias type.",
       );
@@ -166,7 +164,7 @@ export const llm_schema_station = (props: {
       insert(
         llm_schema_station({
           ...props,
-          metadata: alias.value,
+          metadata: alias.type.value,
         }),
       );
 

package/src/programmers/json/JsonSchemasProgrammer.ts

@@ -30,12 +30,12 @@ export namespace JsonSchemasProgrammer {
       output.push("JSON schema does not support Set type.");
     for (const native of metadata.natives)
       if (
-        AtomicPredicator.native(native) === false &&
-        native !== "Date" &&
-        native !== "Blob" &&
-        native !== "File"
+        AtomicPredicator.native(native.name) === false &&
+        native.name !== "Date" &&
+        native.name !== "Blob" &&
+        native.name !== "File"
       )
-        output.push(`JSON schema does not support ${native} type.`);
+        output.push(`JSON schema does not support ${native.name} type.`);
     return output;
   };
 

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -235,10 +235,10 @@ export namespace JsonStringifyProgrammer {
         type: "resolved",
         is:
           props.metadata.escaped.original.size() === 1 &&
-          props.metadata.escaped.original.natives[0] === "Date"
+          props.metadata.escaped.original.natives[0]?.name === "Date"
             ? () =>
                 check_native({
-                  type: "Date",
+                  name: "Date",
                   input: props.input,
                 })
             : () =>
@@ -427,14 +427,14 @@ export namespace JsonStringifyProgrammer {
           type: "object",
           is: () =>
             check_native({
-              type: native,
+              name: native.name,
               input: props.input,
             }),
           value: () =>
-            AtomicPredicator.native(native)
+            AtomicPredicator.native(native.name)
               ? decode_atomic({
                   ...props,
-                  type: native.toLowerCase() as Atomic.Literal,
+                  type: native.name.toLowerCase() as Atomic.Literal,
                 })
               : ts.factory.createStringLiteral("{}"),
         });

package/src/programmers/llm/LlmSchemaProgrammer.ts

@@ -26,14 +26,14 @@ export namespace LlmSchemaProgrammer {
       output.push("LLM schema does not support Set type.");
     for (const native of metadata.natives)
       if (
-        AtomicPredicator.native(native) === false &&
-        native !== "Date" &&
-        native !== "Blob" &&
-        native !== "File"
+        AtomicPredicator.native(native.name) === false &&
+        native.name !== "Date" &&
+        native.name !== "Blob" &&
+        native.name !== "File"
       )
-        output.push(`LLM schema does not support ${native} type.`);
+        output.push(`LLM schema does not support ${native.name} type.`);
     if (
-      metadata.aliases.some((a) => a.recursive) ||
+      metadata.aliases.some((a) => a.type.recursive) ||
       metadata.arrays.some((a) => a.type.recursive) ||
       metadata.objects.some((o) => o.type.recursive) ||
       metadata.tuples.some((t) => t.type.recursive)

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -9,7 +9,9 @@ import { TypeFactory } from "../../factories/TypeFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataMap } from "../../schemas/metadata/MetadataMap";
 import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { MetadataSet } from "../../schemas/metadata/MetadataSet";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -270,16 +272,18 @@ export namespace MiscCloneProgrammer {
     for (const native of props.metadata.natives)
       unions.push({
         type: "native",
-        is: () => ExpressionFactory.isInstanceOf(native, props.input),
+        is: () => ExpressionFactory.isInstanceOf(native.name, props.input),
         value: () =>
-          native === "Boolean" || native === "Number" || native === "String"
+          native.name === "Boolean" ||
+          native.name === "Number" ||
+          native.name === "String"
             ? ts.factory.createCallExpression(
                 IdentifierFactory.access(props.input, "valueOf"),
                 undefined,
                 undefined,
               )
             : decode_native({
-                type: native,
+                type: native.name,
                 input: props.input,
               }),
       });
@@ -578,7 +582,7 @@ export namespace MiscCloneProgrammer {
     config: FeatureProgrammer.IConfig;
     functor: FunctionProgrammer;
     input: ts.Expression;
-    sets: Metadata[];
+    sets: MetadataSet[];
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression =>
     ts.factory.createCallExpression(
@@ -634,7 +638,7 @@ export namespace MiscCloneProgrammer {
     config: FeatureProgrammer.IConfig;
     functor: FunctionProgrammer;
     input: ts.Expression;
-    maps: Metadata.Entry[];
+    maps: MetadataMap[];
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression =>
     ts.factory.createCallExpression(
@@ -967,9 +971,9 @@ export namespace MiscCloneProgrammer {
         absorb: true,
         validate: (metadata) => {
           const output: string[] = [];
-          if (metadata.natives.some((n) => n === "WeakSet"))
+          if (metadata.natives.some((native) => native.name === "WeakSet"))
             output.push("unable to clone WeakSet");
-          else if (metadata.natives.some((n) => n === "WeakMap"))
+          else if (metadata.natives.some((native) => native.name === "WeakMap"))
             output.push("unable to clone WeakMap");
           return output;
         },

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -221,7 +221,7 @@ export namespace MiscPruneProgrammer {
       for (const native of props.metadata.natives)
         unions.push({
           type: "native",
-          is: () => ExpressionFactory.isInstanceOf(native, props.input),
+          is: () => ExpressionFactory.isInstanceOf(native.name, props.input),
           value: () => ts.factory.createReturnStatement(),
         });
     if (props.metadata.sets.length)

package/src/programmers/notations/NotationGeneralProgrammer.ts

@@ -9,7 +9,9 @@ import { TypeFactory } from "../../factories/TypeFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataMap } from "../../schemas/metadata/MetadataMap";
 import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { MetadataSet } from "../../schemas/metadata/MetadataSet";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -298,19 +300,21 @@ export namespace NotationGeneralProgrammer {
           }),
       });
     for (const native of props.metadata.natives) {
-      if (native === "WeakSet" || native === "WeakMap") continue;
+      if (native.name === "WeakSet" || native.name === "WeakMap") continue;
       unions.push({
         type: "native",
-        is: () => ExpressionFactory.isInstanceOf(native, props.input),
+        is: () => ExpressionFactory.isInstanceOf(native.name, props.input),
         value: () =>
-          native === "Boolean" || native === "Number" || native === "String"
+          native.name === "Boolean" ||
+          native.name === "Number" ||
+          native.name === "String"
             ? ts.factory.createCallExpression(
                 IdentifierFactory.access(props.input, "valueOf"),
                 undefined,
                 undefined,
               )
             : decode_native({
-                name: native,
+                name: native.name,
                 input: props.input,
               }),
       });
@@ -530,7 +534,7 @@ export namespace NotationGeneralProgrammer {
     functor: FunctionProgrammer;
     input: ts.Expression;
     explore: FeatureProgrammer.IExplore;
-    sets: Metadata[];
+    sets: Array<MetadataSet>;
   }): ts.Expression =>
     ts.factory.createCallExpression(
       UnionExplorer.set({
@@ -585,7 +589,7 @@ export namespace NotationGeneralProgrammer {
     config: FeatureProgrammer.IConfig;
     functor: FunctionProgrammer;
     input: ts.Expression;
-    maps: Metadata.Entry[];
+    maps: Array<MetadataMap>;
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression =>
     ts.factory.createCallExpression(