typia 7.6.2-dev.20250205 → 7.6.2

package/src/transformers/features/json/JsonSchemasTransformer.ts

@@ -1,145 +1,145 @@
-import ts from "typescript";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { IJsonSchemaCollection } from "../../../schemas/json/IJsonSchemaCollection";
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { JsonSchemasProgrammer } from "../../../programmers/json/JsonSchemasProgrammer";
-
-import { ValidationPipe } from "../../../typings/ValidationPipe";
-
-import { ITransformProps } from "../../ITransformProps";
-import { TransformerError } from "../../TransformerError";
-
-export namespace JsonSchemasTransformer {
-  export const transform = (
-    props: Pick<ITransformProps, "context" | "expression">,
-  ): ts.Expression => {
-    if (!props.expression.typeArguments?.length)
-      throw new TransformerError({
-        code: "typia.json.application",
-        message: "no generic argument.",
-      });
-
-    //----
-    // GET ARGUMENTS
-    //----
-    // VALIDATE TUPLE ARGUMENTS
-    const top: ts.Node = props.expression.typeArguments[0]!;
-    if (!ts.isTupleTypeNode(top)) return props.expression;
-    else if (top.elements.some((child) => !ts.isTypeNode(child)))
-      return props.expression;
-
-    // GET TYPES
-    const types: ts.Type[] = top.elements.map((child) =>
-      props.context.checker.getTypeFromTypeNode(child as ts.TypeNode),
-    );
-    if (types.some((t) => t.isTypeParameter()))
-      throw new TransformerError({
-        code: "typia.json.application",
-        message: "non-specified generic argument(s).",
-      });
-
-    // ADDITIONAL PARAMETERS
-    const version: "3.0" | "3.1" = get_parameter<"3.0" | "3.1">({
-      checker: props.context.checker,
-      name: "Version",
-      is: (str) => str === "3.0" || str === "3.1",
-      cast: (str) => str as "3.0" | "3.1",
-      default: () => "3.1",
-    })(props.expression.typeArguments[1]);
-
-    //----
-    // GENERATORS
-    //----
-    // METADATA
-    const analyze = (validate: boolean): Metadata[] => {
-      const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
-        types.map((type) =>
-          MetadataFactory.analyze({
-            checker: props.context.checker,
-            transformer: props.context.transformer,
-            options: {
-              absorb: validate,
-              constant: true,
-              escape: true,
-              validate:
-                validate === true ? JsonSchemasProgrammer.validate : undefined,
-            },
-            collection: new MetadataCollection({
-              replace: MetadataCollection.replace,
-            }),
-            type,
-          }),
-        );
-      const metadatas: Metadata[] = [];
-      const errors: MetadataFactory.IError[] = [];
-      for (const r of results) {
-        if (r.success === false) errors.push(...r.errors);
-        else metadatas.push(r.data);
-      }
-      if (errors.length)
-        throw TransformerError.from({
-          code: "typia.json.application",
-          errors,
-        });
-      return metadatas;
-    };
-    analyze(true);
-
-    // APPLICATION
-    const app: IJsonSchemaCollection<any> = JsonSchemasProgrammer.write({
-      version,
-      metadatas: analyze(false),
-    });
-    return ts.factory.createAsExpression(
-      LiteralFactory.write(app),
-      props.context.importer.type({
-        file: "typia",
-        name: "IJsonSchemaCollection",
-        arguments: [
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral(version),
-          ),
-        ],
-      }),
-    );
-  };
-
-  const get_parameter =
-    <Value>(props: {
-      checker: ts.TypeChecker;
-      name: string;
-      is: (value: string) => boolean;
-      cast: (value: string) => Value;
-      default: () => Value;
-    }) =>
-    (node: ts.TypeNode | undefined): Value => {
-      if (!node) return props.default();
-
-      // CHECK LITERAL TYPE
-      const type: ts.Type = props.checker.getTypeFromTypeNode(node);
-      if (
-        !type.isLiteral() &&
-        (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
-      )
-        throw new TransformerError({
-          code: "typia.json.application",
-          message: `generic argument "${props.name}" must be constant.`,
-        });
-
-      // GET VALUE AND VALIDATE IT
-      const value = type.isLiteral()
-        ? type.value
-        : props.checker.typeToString(type);
-      if (typeof value !== "string" || props.is(value) === false)
-        throw new TransformerError({
-          code: "typia.json.application",
-          message: `invalid value on generic argument "${props.name}".`,
-        });
-      return props.cast(value);
-    };
-}
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { IJsonSchemaCollection } from "../../../schemas/json/IJsonSchemaCollection";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { JsonSchemasProgrammer } from "../../../programmers/json/JsonSchemasProgrammer";
+
+import { ValidationPipe } from "../../../typings/ValidationPipe";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace JsonSchemasTransformer {
+  export const transform = (
+    props: Pick<ITransformProps, "context" | "expression">,
+  ): ts.Expression => {
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.json.application",
+        message: "no generic argument.",
+      });
+
+    //----
+    // GET ARGUMENTS
+    //----
+    // VALIDATE TUPLE ARGUMENTS
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (!ts.isTupleTypeNode(top)) return props.expression;
+    else if (top.elements.some((child) => !ts.isTypeNode(child)))
+      return props.expression;
+
+    // GET TYPES
+    const types: ts.Type[] = top.elements.map((child) =>
+      props.context.checker.getTypeFromTypeNode(child as ts.TypeNode),
+    );
+    if (types.some((t) => t.isTypeParameter()))
+      throw new TransformerError({
+        code: "typia.json.application",
+        message: "non-specified generic argument(s).",
+      });
+
+    // ADDITIONAL PARAMETERS
+    const version: "3.0" | "3.1" = get_parameter<"3.0" | "3.1">({
+      checker: props.context.checker,
+      name: "Version",
+      is: (str) => str === "3.0" || str === "3.1",
+      cast: (str) => str as "3.0" | "3.1",
+      default: () => "3.1",
+    })(props.expression.typeArguments[1]);
+
+    //----
+    // GENERATORS
+    //----
+    // METADATA
+    const analyze = (validate: boolean): Metadata[] => {
+      const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
+        types.map((type) =>
+          MetadataFactory.analyze({
+            checker: props.context.checker,
+            transformer: props.context.transformer,
+            options: {
+              absorb: validate,
+              constant: true,
+              escape: true,
+              validate:
+                validate === true ? JsonSchemasProgrammer.validate : undefined,
+            },
+            collection: new MetadataCollection({
+              replace: MetadataCollection.replace,
+            }),
+            type,
+          }),
+        );
+      const metadatas: Metadata[] = [];
+      const errors: MetadataFactory.IError[] = [];
+      for (const r of results) {
+        if (r.success === false) errors.push(...r.errors);
+        else metadatas.push(r.data);
+      }
+      if (errors.length)
+        throw TransformerError.from({
+          code: "typia.json.application",
+          errors,
+        });
+      return metadatas;
+    };
+    analyze(true);
+
+    // APPLICATION
+    const app: IJsonSchemaCollection<any> = JsonSchemasProgrammer.write({
+      version,
+      metadatas: analyze(false),
+    });
+    return ts.factory.createAsExpression(
+      LiteralFactory.write(app),
+      props.context.importer.type({
+        file: "typia",
+        name: "IJsonSchemaCollection",
+        arguments: [
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral(version),
+          ),
+        ],
+      }),
+    );
+  };
+
+  const get_parameter =
+    <Value>(props: {
+      checker: ts.TypeChecker;
+      name: string;
+      is: (value: string) => boolean;
+      cast: (value: string) => Value;
+      default: () => Value;
+    }) =>
+    (node: ts.TypeNode | undefined): Value => {
+      if (!node) return props.default();
+
+      // CHECK LITERAL TYPE
+      const type: ts.Type = props.checker.getTypeFromTypeNode(node);
+      if (
+        !type.isLiteral() &&
+        (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
+      )
+        throw new TransformerError({
+          code: "typia.json.application",
+          message: `generic argument "${props.name}" must be constant.`,
+        });
+
+      // GET VALUE AND VALIDATE IT
+      const value = type.isLiteral()
+        ? type.value
+        : props.checker.typeToString(type);
+      if (typeof value !== "string" || props.is(value) === false)
+        throw new TransformerError({
+          code: "typia.json.application",
+          message: `invalid value on generic argument "${props.name}".`,
+        });
+      return props.cast(value);
+    };
+}

package/src/transformers/features/json/JsonStringifyTransformer.ts

@@ -1,13 +1,13 @@
-import { JsonStringifyProgrammer } from "../../../programmers/json/JsonStringifyProgrammer";
-
-import { ITransformProps } from "../../ITransformProps";
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace JsonStringifyTransformer {
-  export const transform = (props: ITransformProps) =>
-    GenericTransformer.scalar({
-      ...props,
-      method: "json.stringify",
-      write: JsonStringifyProgrammer.write,
-    });
-}
+import { JsonStringifyProgrammer } from "../../../programmers/json/JsonStringifyProgrammer";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonStringifyTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.stringify",
+      write: JsonStringifyProgrammer.write,
+    });
+}

package/src/transformers/features/json/JsonValidateParseTransformer.ts

@@ -1,13 +1,13 @@
-import { JsonValidateParseProgrammer } from "../../../programmers/json/JsonValidateParseProgrammer";
-
-import { ITransformProps } from "../../ITransformProps";
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace JsonValidateParseTransformer {
-  export const transform = (props: ITransformProps) =>
-    GenericTransformer.scalar({
-      ...props,
-      method: "json.validateParse",
-      write: JsonValidateParseProgrammer.write,
-    });
-}
+import { JsonValidateParseProgrammer } from "../../../programmers/json/JsonValidateParseProgrammer";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonValidateParseTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.validateParse",
+      write: JsonValidateParseProgrammer.write,
+    });
+}

package/src/transformers/features/json/JsonValidateStringifyTransformer.ts

@@ -1,13 +1,13 @@
-import { JsonValidateStringifyProgrammer } from "../../../programmers/json/JsonValidateStringifyProgrammer";
-
-import { ITransformProps } from "../../ITransformProps";
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace JsonValidateStringifyTransformer {
-  export const transform = (props: ITransformProps) =>
-    GenericTransformer.scalar({
-      ...props,
-      method: "json.validateStringify",
-      write: JsonValidateStringifyProgrammer.write,
-    });
-}
+import { JsonValidateStringifyProgrammer } from "../../../programmers/json/JsonValidateStringifyProgrammer";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonValidateStringifyTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.validateStringify",
+      write: JsonValidateStringifyProgrammer.write,
+    });
+}

package/src/transformers/features/llm/LlmApplicationOfValidateTransformer.ts

@@ -1,129 +1,129 @@
-import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../../factories/ExpressionFactory";
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-import { StatementFactory } from "../../../factories/StatementFactory";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { LlmApplicationOfValidateProgrammer } from "../../../programmers/llm/LlmApplicationOfValidateProgrammer";
-import { LlmModelPredicator } from "../../../programmers/llm/LlmModelPredicator";
-
-import { ValidationPipe } from "../../../typings/ValidationPipe";
-
-import { ITransformProps } from "../../ITransformProps";
-import { TransformerError } from "../../TransformerError";
-
-export namespace LlmApplicationOfValidateTransformer {
-  export const transform = (props: ITransformProps): ts.Expression => {
-    // GET GENERIC ARGUMENT
-    if (!props.expression.typeArguments?.length)
-      throw new TransformerError({
-        code: "typia.llm.schema",
-        message: "no generic argument.",
-      });
-
-    const top: ts.Node = props.expression.typeArguments[0]!;
-    if (ts.isTypeNode(top) === false) return props.expression;
-
-    // GET TYPE
-    const model: ILlmSchema.Model = LlmModelPredicator.getModel({
-      checker: props.context.checker,
-      method: "application",
-      node: props.expression.typeArguments[1],
-    });
-    const config: Partial<ILlmSchema.IConfig> = LlmModelPredicator.getConfig({
-      context: props.context,
-      method: "application",
-      model,
-      node: props.expression.typeArguments[2],
-    }) as Partial<ILlmSchema.IConfig>;
-
-    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
-
-    // VALIDATE TYPE
-    const analyze = (validate: boolean): Metadata => {
-      const result: ValidationPipe<Metadata, MetadataFactory.IError> =
-        MetadataFactory.analyze({
-          checker: props.context.checker,
-          transformer: props.context.transformer,
-          options: {
-            absorb: validate,
-            escape: true,
-            constant: true,
-            functional: true,
-            validate:
-              validate === true
-                ? LlmApplicationOfValidateProgrammer.validate({
-                    model,
-                    config,
-                  })
-                : undefined,
-          },
-          collection: new MetadataCollection({
-            replace: MetadataCollection.replace,
-          }),
-          type,
-        });
-      if (result.success === false)
-        throw TransformerError.from({
-          code: "typia.llm.application",
-          errors: result.errors,
-        });
-      return result.data;
-    };
-    analyze(true);
-
-    // GENERATE LLM APPLICATION
-    const schema: ILlmApplication<ILlmSchema.Model> =
-      LlmApplicationOfValidateProgrammer.write({
-        model,
-        context: props.context,
-        modulo: props.modulo,
-        metadata: analyze(false),
-        config,
-        name: top.getFullText().trim(),
-      });
-    const literal: ts.Expression = ts.factory.createAsExpression(
-      LiteralFactory.write(schema),
-      props.context.importer.type({
-        file: "typia",
-        name: "ILlmApplicationOfValidate",
-        arguments: [
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral(model),
-          ),
-        ],
-      }),
-    );
-    if (!props.expression.arguments?.[0]) return literal;
-
-    return ExpressionFactory.selfCall(
-      ts.factory.createBlock(
-        [
-          StatementFactory.constant({
-            name: "app",
-            value: literal,
-          }),
-          ts.factory.createExpressionStatement(
-            ts.factory.createCallExpression(
-              props.context.importer.internal("llmApplicationFinalize"),
-              undefined,
-              [
-                ts.factory.createIdentifier("app"),
-                ...(props.expression.arguments?.[0]
-                  ? [props.expression.arguments[0]]
-                  : []),
-              ],
-            ),
-          ),
-          ts.factory.createReturnStatement(ts.factory.createIdentifier("app")),
-        ],
-        true,
-      ),
-    );
-  };
-}
+import { ILlmApplication, ILlmSchema } from "@samchon/openapi";
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../../factories/ExpressionFactory";
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+import { StatementFactory } from "../../../factories/StatementFactory";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { LlmApplicationOfValidateProgrammer } from "../../../programmers/llm/LlmApplicationOfValidateProgrammer";
+import { LlmModelPredicator } from "../../../programmers/llm/LlmModelPredicator";
+
+import { ValidationPipe } from "../../../typings/ValidationPipe";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace LlmApplicationOfValidateTransformer {
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.llm.schema",
+        message: "no generic argument.",
+      });
+
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
+
+    // GET TYPE
+    const model: ILlmSchema.Model = LlmModelPredicator.getModel({
+      checker: props.context.checker,
+      method: "application",
+      node: props.expression.typeArguments[1],
+    });
+    const config: Partial<ILlmSchema.IConfig> = LlmModelPredicator.getConfig({
+      context: props.context,
+      method: "application",
+      model,
+      node: props.expression.typeArguments[2],
+    }) as Partial<ILlmSchema.IConfig>;
+
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
+
+    // VALIDATE TYPE
+    const analyze = (validate: boolean): Metadata => {
+      const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            absorb: validate,
+            escape: true,
+            constant: true,
+            functional: true,
+            validate:
+              validate === true
+                ? LlmApplicationOfValidateProgrammer.validate({
+                    model,
+                    config,
+                  })
+                : undefined,
+          },
+          collection: new MetadataCollection({
+            replace: MetadataCollection.replace,
+          }),
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.application",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
+
+    // GENERATE LLM APPLICATION
+    const schema: ILlmApplication<ILlmSchema.Model> =
+      LlmApplicationOfValidateProgrammer.write({
+        model,
+        context: props.context,
+        modulo: props.modulo,
+        metadata: analyze(false),
+        config,
+        name: top.getFullText().trim(),
+      });
+    const literal: ts.Expression = ts.factory.createAsExpression(
+      LiteralFactory.write(schema),
+      props.context.importer.type({
+        file: "typia",
+        name: "ILlmApplicationOfValidate",
+        arguments: [
+          ts.factory.createLiteralTypeNode(
+            ts.factory.createStringLiteral(model),
+          ),
+        ],
+      }),
+    );
+    if (!props.expression.arguments?.[0]) return literal;
+
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          StatementFactory.constant({
+            name: "app",
+            value: literal,
+          }),
+          ts.factory.createExpressionStatement(
+            ts.factory.createCallExpression(
+              props.context.importer.internal("llmApplicationFinalize"),
+              undefined,
+              [
+                ts.factory.createIdentifier("app"),
+                ...(props.expression.arguments?.[0]
+                  ? [props.expression.arguments[0]]
+                  : []),
+              ],
+            ),
+          ),
+          ts.factory.createReturnStatement(ts.factory.createIdentifier("app")),
+        ],
+        true,
+      ),
+    );
+  };
+}