typia 7.0.0-dev.20241005 → 7.0.0-dev.20241008

package/src/programmers/llm/LlmApplicationProgrammer.ts

@@ -1,235 +1,235 @@
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
-import { ILlmFunction } from "@samchon/openapi/lib/structures/ILlmFunction";
-
-import { MetadataFactory } from "../../factories/MetadataFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataFunction } from "../../schemas/metadata/MetadataFunction";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { IJsDocTagInfo } from "../../module";
-import { LlmSchemaProgrammer } from "./LlmSchemaProgrammer";
-
-export namespace LlmApplicationProgrammer {
-  export const validate = (
-    metadata: Metadata,
-    explore: MetadataFactory.IExplore,
-  ): string[] => {
-    if (explore.top === false) return LlmSchemaProgrammer.validate(metadata);
-
-    const output: string[] = [];
-    const valid: boolean =
-      metadata.size() === 1 &&
-      metadata.objects.length === 1 &&
-      metadata.isRequired() === true &&
-      metadata.nullable === false;
-    if (valid === false)
-      output.push(
-        "LLM application's generic arugment must be a class/interface type.",
-      );
-
-    const object: MetadataObject | undefined = metadata.objects[0];
-    if (object !== undefined) {
-      if (object.properties.some((p) => p.key.isSoleLiteral() === false))
-        output.push("LLM application does not allow dynamic keys.");
-      let least: boolean = false;
-      for (const p of object.properties) {
-        const value: Metadata = p.value;
-        if (value.functions.length) {
-          least ||= true;
-          if (valid === false) {
-            if (value.functions.length !== 1 || value.size() !== 1)
-              output.push(
-                "LLM application's function type does not allow union type.",
-              );
-            if (value.isRequired() === false)
-              output.push("LLM application's function type must be required.");
-            if (value.nullable === true)
-              output.push(
-                "LLM application's function type must not be nullable.",
-              );
-          }
-        }
-      }
-      if (least === false)
-        output.push(
-          "LLM application's target type must have at least a function type.",
-        );
-    }
-    return output;
-  };
-
-  export const write = (metadata: Metadata): ILlmApplication => {
-    const errors: string[] = validate(metadata, {
-      top: true,
-      object: null,
-      property: null,
-      parameter: null,
-      nested: null,
-      aliased: false,
-      escaped: false,
-      output: false,
-    });
-    if (errors.length)
-      throw new Error("Failed to write LLM application: " + errors.join("\n"));
-
-    const object: MetadataObject = metadata.objects[0]!;
-    return {
-      functions: object.properties
-        .filter(
-          (p) =>
-            p.value.functions.length === 1 &&
-            p.value.size() === 1 &&
-            p.key.isSoleLiteral(),
-        )
-        .filter(
-          (p) => p.jsDocTags.find((tag) => tag.name === "hidden") === undefined,
-        )
-        .map((p) =>
-          writeFunction({
-            name: p.key.getSoleLiteral()!,
-            function: p.value.functions[0]!,
-            description: p.description,
-            jsDocTags: p.jsDocTags,
-          }),
-        ),
-      options: {
-        separate: null,
-      },
-    };
-  };
-
-  const writeFunction = (props: {
-    name: string;
-    function: MetadataFunction;
-    description: string | null;
-    jsDocTags: IJsDocTagInfo[];
-  }): ILlmFunction => {
-    const deprecated: boolean = props.jsDocTags.some(
-      (tag) => tag.name === "deprecated",
-    );
-    const tags: string[] = props.jsDocTags
-      .map((tag) =>
-        tag.name === "tag"
-          ? (tag.text?.filter((elem) => elem.kind === "text") ?? [])
-          : [],
-      )
-      .flat()
-      .map((elem) => elem.text)
-      .map((str) => str.trim().split(" ")[0] ?? "")
-      .filter((str) => !!str.length);
-    return {
-      name: props.name,
-      parameters: props.function.parameters.map((p) => {
-        const jsDocTagDescription: string | null = writeDescriptionFromJsDocTag(
-          {
-            jsDocTags: p.jsDocTags,
-            name: "param",
-            parameter: p.name,
-          },
-        );
-        return writeSchema({
-          metadata: p.type,
-          description: jsDocTagDescription ?? p.description,
-          jsDocTags: jsDocTagDescription ? [] : p.jsDocTags,
-        });
-      }),
-      output:
-        props.function.output.size() || props.function.output.nullable
-          ? writeSchema({
-              metadata: props.function.output,
-              description:
-                writeDescriptionFromJsDocTag({
-                  jsDocTags: props.jsDocTags,
-                  name: "return",
-                }) ??
-                writeDescriptionFromJsDocTag({
-                  jsDocTags: props.jsDocTags,
-                  name: "returns",
-                }),
-              jsDocTags: [],
-            })
-          : undefined,
-      description: props.description ?? undefined,
-      deprecated: deprecated || undefined,
-      tags: tags.length ? tags : undefined,
-    };
-  };
-
-  const writeSchema = (props: {
-    metadata: Metadata;
-    description: string | null;
-    jsDocTags: IJsDocTagInfo[];
-  }): ILlmSchema => {
-    const schema: ILlmSchema = LlmSchemaProgrammer.write(props.metadata);
-    const explicit: Pick<ILlmSchema, "title" | "description"> =
-      writeDescription({
-        description: props.description,
-        jsDocTags: props.jsDocTags,
-      });
-    return {
-      ...schema,
-      ...(!!explicit.title?.length || !!explicit.description?.length
-        ? explicit
-        : {}),
-    };
-  };
-
-  const writeDescription = (props: {
-    description: string | null;
-    jsDocTags: IJsDocTagInfo[];
-  }): Pick<ILlmSchema, "title" | "description"> => {
-    const title: string | undefined = (() => {
-      const [explicit] = getJsDocTexts({
-        jsDocTags: props.jsDocTags,
-        name: "title",
-      });
-      if (explicit?.length) return explicit;
-      else if (!props.description?.length) return undefined;
-
-      const index: number = props.description.indexOf("\n");
-      const top: string = (
-        index === -1 ? props.description : props.description.substring(0, index)
-      ).trim();
-      return top.endsWith(".") ? top.substring(0, top.length - 1) : undefined;
-    })();
-    return {
-      title: title,
-      description: props.description?.length ? props.description : undefined,
-    } as any;
-  };
-
-  const writeDescriptionFromJsDocTag = (props: {
-    jsDocTags: IJsDocTagInfo[];
-    name: string;
-    parameter?: string;
-  }): string | null => {
-    const parametric: (elem: IJsDocTagInfo) => boolean = props.parameter
-      ? (tag) =>
-          tag.text!.find(
-            (elem) =>
-              elem.kind === "parameterName" && elem.text === props.parameter,
-          ) !== undefined
-      : () => true;
-    const tag: IJsDocTagInfo | undefined = props.jsDocTags.find(
-      (tag) => tag.name === props.name && tag.text && parametric(tag),
-    );
-    return tag && tag.text
-      ? (tag.text.find((elem) => elem.kind === "text")?.text ?? null)
-      : null;
-  };
-
-  const getJsDocTexts = (props: {
-    jsDocTags: IJsDocTagInfo[];
-    name: string;
-  }): string[] =>
-    props.jsDocTags
-      .filter(
-        (tag) =>
-          tag.name === props.name &&
-          tag.text &&
-          tag.text.find((elem) => elem.kind === "text" && elem.text.length) !==
-            undefined,
-      )
-      .map((tag) => tag.text!.find((elem) => elem.kind === "text")!.text);
-}
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import { ILlmFunction } from "@samchon/openapi/lib/structures/ILlmFunction";
+
+import { MetadataFactory } from "../../factories/MetadataFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataFunction } from "../../schemas/metadata/MetadataFunction";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+
+import { IJsDocTagInfo } from "../../module";
+import { LlmSchemaProgrammer } from "./LlmSchemaProgrammer";
+
+export namespace LlmApplicationProgrammer {
+  export const validate = (
+    metadata: Metadata,
+    explore: MetadataFactory.IExplore,
+  ): string[] => {
+    if (explore.top === false) return LlmSchemaProgrammer.validate(metadata);
+
+    const output: string[] = [];
+    const valid: boolean =
+      metadata.size() === 1 &&
+      metadata.objects.length === 1 &&
+      metadata.isRequired() === true &&
+      metadata.nullable === false;
+    if (valid === false)
+      output.push(
+        "LLM application's generic arugment must be a class/interface type.",
+      );
+
+    const object: MetadataObject | undefined = metadata.objects[0];
+    if (object !== undefined) {
+      if (object.properties.some((p) => p.key.isSoleLiteral() === false))
+        output.push("LLM application does not allow dynamic keys.");
+      let least: boolean = false;
+      for (const p of object.properties) {
+        const value: Metadata = p.value;
+        if (value.functions.length) {
+          least ||= true;
+          if (valid === false) {
+            if (value.functions.length !== 1 || value.size() !== 1)
+              output.push(
+                "LLM application's function type does not allow union type.",
+              );
+            if (value.isRequired() === false)
+              output.push("LLM application's function type must be required.");
+            if (value.nullable === true)
+              output.push(
+                "LLM application's function type must not be nullable.",
+              );
+          }
+        }
+      }
+      if (least === false)
+        output.push(
+          "LLM application's target type must have at least a function type.",
+        );
+    }
+    return output;
+  };
+
+  export const write = (metadata: Metadata): ILlmApplication => {
+    const errors: string[] = validate(metadata, {
+      top: true,
+      object: null,
+      property: null,
+      parameter: null,
+      nested: null,
+      aliased: false,
+      escaped: false,
+      output: false,
+    });
+    if (errors.length)
+      throw new Error("Failed to write LLM application: " + errors.join("\n"));
+
+    const object: MetadataObject = metadata.objects[0]!;
+    return {
+      functions: object.properties
+        .filter(
+          (p) =>
+            p.value.functions.length === 1 &&
+            p.value.size() === 1 &&
+            p.key.isSoleLiteral(),
+        )
+        .filter(
+          (p) => p.jsDocTags.find((tag) => tag.name === "hidden") === undefined,
+        )
+        .map((p) =>
+          writeFunction({
+            name: p.key.getSoleLiteral()!,
+            function: p.value.functions[0]!,
+            description: p.description,
+            jsDocTags: p.jsDocTags,
+          }),
+        ),
+      options: {
+        separate: null,
+      },
+    };
+  };
+
+  const writeFunction = (props: {
+    name: string;
+    function: MetadataFunction;
+    description: string | null;
+    jsDocTags: IJsDocTagInfo[];
+  }): ILlmFunction => {
+    const deprecated: boolean = props.jsDocTags.some(
+      (tag) => tag.name === "deprecated",
+    );
+    const tags: string[] = props.jsDocTags
+      .map((tag) =>
+        tag.name === "tag"
+          ? (tag.text?.filter((elem) => elem.kind === "text") ?? [])
+          : [],
+      )
+      .flat()
+      .map((elem) => elem.text)
+      .map((str) => str.trim().split(" ")[0] ?? "")
+      .filter((str) => !!str.length);
+    return {
+      name: props.name,
+      parameters: props.function.parameters.map((p) => {
+        const jsDocTagDescription: string | null = writeDescriptionFromJsDocTag(
+          {
+            jsDocTags: p.jsDocTags,
+            name: "param",
+            parameter: p.name,
+          },
+        );
+        return writeSchema({
+          metadata: p.type,
+          description: jsDocTagDescription ?? p.description,
+          jsDocTags: jsDocTagDescription ? [] : p.jsDocTags,
+        });
+      }),
+      output:
+        props.function.output.size() || props.function.output.nullable
+          ? writeSchema({
+              metadata: props.function.output,
+              description:
+                writeDescriptionFromJsDocTag({
+                  jsDocTags: props.jsDocTags,
+                  name: "return",
+                }) ??
+                writeDescriptionFromJsDocTag({
+                  jsDocTags: props.jsDocTags,
+                  name: "returns",
+                }),
+              jsDocTags: [],
+            })
+          : undefined,
+      description: props.description ?? undefined,
+      deprecated: deprecated || undefined,
+      tags: tags.length ? tags : undefined,
+    };
+  };
+
+  const writeSchema = (props: {
+    metadata: Metadata;
+    description: string | null;
+    jsDocTags: IJsDocTagInfo[];
+  }): ILlmSchema => {
+    const schema: ILlmSchema = LlmSchemaProgrammer.write(props.metadata);
+    const explicit: Pick<ILlmSchema, "title" | "description"> =
+      writeDescription({
+        description: props.description,
+        jsDocTags: props.jsDocTags,
+      });
+    return {
+      ...schema,
+      ...(!!explicit.title?.length || !!explicit.description?.length
+        ? explicit
+        : {}),
+    };
+  };
+
+  const writeDescription = (props: {
+    description: string | null;
+    jsDocTags: IJsDocTagInfo[];
+  }): Pick<ILlmSchema, "title" | "description"> => {
+    const title: string | undefined = (() => {
+      const [explicit] = getJsDocTexts({
+        jsDocTags: props.jsDocTags,
+        name: "title",
+      });
+      if (explicit?.length) return explicit;
+      else if (!props.description?.length) return undefined;
+
+      const index: number = props.description.indexOf("\n");
+      const top: string = (
+        index === -1 ? props.description : props.description.substring(0, index)
+      ).trim();
+      return top.endsWith(".") ? top.substring(0, top.length - 1) : undefined;
+    })();
+    return {
+      title: title,
+      description: props.description?.length ? props.description : undefined,
+    } as any;
+  };
+
+  const writeDescriptionFromJsDocTag = (props: {
+    jsDocTags: IJsDocTagInfo[];
+    name: string;
+    parameter?: string;
+  }): string | null => {
+    const parametric: (elem: IJsDocTagInfo) => boolean = props.parameter
+      ? (tag) =>
+          tag.text!.find(
+            (elem) =>
+              elem.kind === "parameterName" && elem.text === props.parameter,
+          ) !== undefined
+      : () => true;
+    const tag: IJsDocTagInfo | undefined = props.jsDocTags.find(
+      (tag) => tag.name === props.name && tag.text && parametric(tag),
+    );
+    return tag && tag.text
+      ? (tag.text.find((elem) => elem.kind === "text")?.text ?? null)
+      : null;
+  };
+
+  const getJsDocTexts = (props: {
+    jsDocTags: IJsDocTagInfo[];
+    name: string;
+  }): string[] =>
+    props.jsDocTags
+      .filter(
+        (tag) =>
+          tag.name === props.name &&
+          tag.text &&
+          tag.text.find((elem) => elem.kind === "text" && elem.text.length) !==
+            undefined,
+      )
+      .map((tag) => tag.text!.find((elem) => elem.kind === "text")!.text);
+}

package/src/programmers/llm/LlmSchemaProgrammer.ts

@@ -1,51 +1,51 @@
-import { ILlmSchema } from "@samchon/openapi";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { AtomicPredicator } from "../helpers/AtomicPredicator";
-import { llm_schema_station } from "../internal/llm_schema_station";
-
-export namespace LlmSchemaProgrammer {
-  export const validate = (metadata: Metadata): string[] => {
-    const output: string[] = [];
-    if (
-      metadata.atomics.some((a) => a.type === "bigint") ||
-      metadata.constants.some((c) => c.type === "bigint")
-    )
-      output.push("LLM schema does not support bigint type.");
-    if (
-      metadata.tuples.some((t) =>
-        t.type.elements.some((e) => e.isRequired() === false),
-      ) ||
-      metadata.arrays.some((a) => a.type.value.isRequired() === false)
-    )
-      output.push("LLM schema does not support undefined type in array.");
-    if (metadata.maps.length)
-      output.push("LLM schema does not support Map type.");
-    if (metadata.sets.length)
-      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"
-      )
-        output.push(`LLM schema does not support ${native} type.`);
-    if (
-      metadata.aliases.some((a) => a.recursive) ||
-      metadata.arrays.some((a) => a.type.recursive) ||
-      metadata.objects.some((o) => o.recursive) ||
-      metadata.tuples.some((t) => t.type.recursive)
-    )
-      output.push("LLM schema does not support recursive type.");
-    return output;
-  };
-
-  export const write = (metadata: Metadata): ILlmSchema =>
-    llm_schema_station({
-      metadata,
-      blockNever: true,
-      attribute: {},
-    });
-}
+import { ILlmSchema } from "@samchon/openapi";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { AtomicPredicator } from "../helpers/AtomicPredicator";
+import { llm_schema_station } from "../internal/llm_schema_station";
+
+export namespace LlmSchemaProgrammer {
+  export const validate = (metadata: Metadata): string[] => {
+    const output: string[] = [];
+    if (
+      metadata.atomics.some((a) => a.type === "bigint") ||
+      metadata.constants.some((c) => c.type === "bigint")
+    )
+      output.push("LLM schema does not support bigint type.");
+    if (
+      metadata.tuples.some((t) =>
+        t.type.elements.some((e) => e.isRequired() === false),
+      ) ||
+      metadata.arrays.some((a) => a.type.value.isRequired() === false)
+    )
+      output.push("LLM schema does not support undefined type in array.");
+    if (metadata.maps.length)
+      output.push("LLM schema does not support Map type.");
+    if (metadata.sets.length)
+      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"
+      )
+        output.push(`LLM schema does not support ${native} type.`);
+    if (
+      metadata.aliases.some((a) => a.recursive) ||
+      metadata.arrays.some((a) => a.type.recursive) ||
+      metadata.objects.some((o) => o.recursive) ||
+      metadata.tuples.some((t) => t.type.recursive)
+    )
+      output.push("LLM schema does not support recursive type.");
+    return output;
+  };
+
+  export const write = (metadata: Metadata): ILlmSchema =>
+    llm_schema_station({
+      metadata,
+      blockNever: true,
+      attribute: {},
+    });
+}

package/src/programmers/misc/MiscAssertCloneProgrammer.ts

@@ -53,7 +53,10 @@ export namespace MiscAssertCloneProgrammer {
         undefined,
         [
           IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
-          AssertProgrammer.Guardian.parameter(props.init),
+          AssertProgrammer.Guardian.parameter({
+            context: props.context,
+            init: props.init,
+          }),
         ],
         clone.arrow.type,
         undefined,

package/src/programmers/misc/MiscAssertPruneProgrammer.ts

@@ -53,7 +53,10 @@ export namespace MiscAssertPruneProgrammer {
         undefined,
         [
           IdentifierFactory.parameter("input", TypeFactory.keyword("any")),
-          AssertProgrammer.Guardian.parameter(props.init),
+          AssertProgrammer.Guardian.parameter({
+            context: props.context,
+            init: props.init,
+          }),
         ],
         ts.factory.createTypeReferenceNode(
           props.name ??

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -856,13 +856,10 @@ export namespace MiscCloneProgrammer {
               TypeFactory.getFullName({ checker: props.context.checker, type }),
           ),
         output: (type, name) =>
-          ts.factory.createImportTypeNode(
-            ts.factory.createLiteralTypeNode(
-              ts.factory.createStringLiteral("typia"),
-            ),
-            undefined,
-            ts.factory.createIdentifier("Resolved"),
-            [
+          props.context.importer.type({
+            file: "typia",
+            name: "Resolved",
+            arguments: [
               ts.factory.createTypeReferenceNode(
                 name ??
                   TypeFactory.getFullName({
@@ -871,8 +868,7 @@ export namespace MiscCloneProgrammer {
                   }),
               ),
             ],
-            false,
-          ),
+          }),
       },
       prefix: PREFIX,
       trace: false,

package/src/programmers/misc/MiscValidateCloneProgrammer.ts

@@ -51,9 +51,11 @@ export namespace MiscValidateCloneProgrammer {
         undefined,
         undefined,
         [IdentifierFactory.parameter("input", TypeFactory.keyword("any"))],
-        ts.factory.createTypeReferenceNode("typia.IValidation", [
-          clone.arrow.type ?? TypeFactory.keyword("any"),
-        ]),
+        props.context.importer.type({
+          file: "typia",
+          name: "IValidation",
+          arguments: [clone.arrow.type ?? TypeFactory.keyword("any")],
+        }),
         undefined,
         ts.factory.createBlock(
           [