typia 6.10.2-dev.20240920 → 6.10.2

package/src/programmers/internal/decode_union_object.ts

@@ -1,99 +1,99 @@
-import ts from "typescript";
-
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-
-/**
- * @internal
- */
-export const decode_union_object =
-  (
-    checker: (
-      input: ts.Expression,
-      obj: MetadataObject,
-      explore: FeatureProgrammer.IExplore,
-    ) => ts.Expression,
-  ) =>
-  (
-    decoder: (
-      input: ts.Expression,
-      obj: MetadataObject,
-      explore: FeatureProgrammer.IExplore,
-    ) => ts.Expression,
-  ) =>
-  (success: (exp: ts.Expression) => ts.Expression) =>
-  (escaper: (value: ts.Expression, expected: string) => ts.Statement) =>
-  (
-    input: ts.Expression,
-    targets: MetadataObject[],
-    explore: FeatureProgrammer.IExplore,
-  ): ts.CallExpression =>
-    ts.factory.createCallExpression(
-      ts.factory.createArrowFunction(
-        undefined,
-        undefined,
-        [],
-        undefined,
-        undefined,
-        iterate(escaper)(
-          input,
-          targets.map((obj) => ({
-            type: "object",
-            is: () => success(checker(input, obj, explore)),
-            value: () => decoder(input, obj, explore),
-          })),
-          `(${targets.map((t) => t.name).join(" | ")})`,
-        ),
-      ),
-      undefined,
-      undefined,
-    );
-
-const iterate =
-  (escaper: (value: ts.Expression, expected: string) => ts.Statement) =>
-  (input: ts.Expression, unions: IUnion[], expected: string) => {
-    interface IBranch {
-      condition: null | ts.Expression;
-      value: ts.Expression;
-    }
-    const branches: IBranch[] = [];
-
-    for (const u of unions) {
-      const condition: ts.Expression = u.is();
-      if (condition.kind === ts.SyntaxKind.TrueKeyword) {
-        branches.push({
-          condition: null,
-          value: u.value(),
-        });
-        break;
-      }
-      branches.push({
-        condition,
-        value: u.value(),
-      });
-    }
-    if (branches.length === 0)
-      return ts.factory.createBlock([escaper(input, expected)], true);
-    else if (branches.length === 1 && branches[0]!.condition === null)
-      return branches[0]!.value;
-
-    const statements: ts.Statement[] = branches.map((b) =>
-      b.condition !== null
-        ? ts.factory.createIfStatement(
-            b.condition,
-            ts.factory.createReturnStatement(b.value),
-            undefined,
-          )
-        : ts.factory.createReturnStatement(b.value),
-    );
-    if (branches.at(-1)!.condition !== null)
-      statements.push(escaper(input, expected));
-    return ts.factory.createBlock(statements, true);
-  };
-
-interface IUnion {
-  type: string;
-  is: () => ts.Expression;
-  value: () => ts.Expression;
-}
+import ts from "typescript";
+
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+
+/**
+ * @internal
+ */
+export const decode_union_object =
+  (
+    checker: (
+      input: ts.Expression,
+      obj: MetadataObject,
+      explore: FeatureProgrammer.IExplore,
+    ) => ts.Expression,
+  ) =>
+  (
+    decoder: (
+      input: ts.Expression,
+      obj: MetadataObject,
+      explore: FeatureProgrammer.IExplore,
+    ) => ts.Expression,
+  ) =>
+  (success: (exp: ts.Expression) => ts.Expression) =>
+  (escaper: (value: ts.Expression, expected: string) => ts.Statement) =>
+  (
+    input: ts.Expression,
+    targets: MetadataObject[],
+    explore: FeatureProgrammer.IExplore,
+  ): ts.CallExpression =>
+    ts.factory.createCallExpression(
+      ts.factory.createArrowFunction(
+        undefined,
+        undefined,
+        [],
+        undefined,
+        undefined,
+        iterate(escaper)(
+          input,
+          targets.map((obj) => ({
+            type: "object",
+            is: () => success(checker(input, obj, explore)),
+            value: () => decoder(input, obj, explore),
+          })),
+          `(${targets.map((t) => t.name).join(" | ")})`,
+        ),
+      ),
+      undefined,
+      undefined,
+    );
+
+const iterate =
+  (escaper: (value: ts.Expression, expected: string) => ts.Statement) =>
+  (input: ts.Expression, unions: IUnion[], expected: string) => {
+    interface IBranch {
+      condition: null | ts.Expression;
+      value: ts.Expression;
+    }
+    const branches: IBranch[] = [];
+
+    for (const u of unions) {
+      const condition: ts.Expression = u.is();
+      if (condition.kind === ts.SyntaxKind.TrueKeyword) {
+        branches.push({
+          condition: null,
+          value: u.value(),
+        });
+        break;
+      }
+      branches.push({
+        condition,
+        value: u.value(),
+      });
+    }
+    if (branches.length === 0)
+      return ts.factory.createBlock([escaper(input, expected)], true);
+    else if (branches.length === 1 && branches[0]!.condition === null)
+      return branches[0]!.value;
+
+    const statements: ts.Statement[] = branches.map((b) =>
+      b.condition !== null
+        ? ts.factory.createIfStatement(
+            b.condition,
+            ts.factory.createReturnStatement(b.value),
+            undefined,
+          )
+        : ts.factory.createReturnStatement(b.value),
+    );
+    if (branches.at(-1)!.condition !== null)
+      statements.push(escaper(input, expected));
+    return ts.factory.createBlock(statements, true);
+  };
+
+interface IUnion {
+  type: string;
+  is: () => ts.Expression;
+  value: () => ts.Expression;
+}

package/src/programmers/internal/feature_object_entries.ts

@@ -1,58 +1,58 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { Escaper } from "../../utils/Escaper";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
-
-/**
- * @internal
- */
-export const feature_object_entries =
-  <Output extends ts.ConciseBody>(
-    config: Pick<
-      FeatureProgrammer.IConfig<Output>,
-      "decoder" | "path" | "trace"
-    >,
-  ) =>
-  (importer: FunctionImporter) =>
-  (obj: MetadataObject) =>
-  (input: ts.Expression, from: "object" | "top" | "array" = "object") =>
-    obj.properties.map((prop) => {
-      const sole: string | null = prop.key.getSoleLiteral();
-      const propInput =
-        sole === null
-          ? ts.factory.createIdentifier("value")
-          : Escaper.variable(sole)
-            ? ts.factory.createPropertyAccessExpression(
-                input,
-                ts.factory.createIdentifier(sole),
-              )
-            : ts.factory.createElementAccessExpression(
-                input,
-                ts.factory.createStringLiteral(sole),
-              );
-
-      return {
-        input: propInput,
-        key: prop.key,
-        meta: prop.value,
-        expression: config.decoder()(propInput, prop.value, {
-          tracable: config.path || config.trace,
-          source: "function",
-          from,
-          postfix: config.trace
-            ? sole !== null
-              ? IdentifierFactory.postfix(sole)
-              : (() => {
-                  importer.use("join");
-                  return `$join(key)`;
-                })()
-            : "",
-        }),
-      };
-    });
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporter";
+
+/**
+ * @internal
+ */
+export const feature_object_entries =
+  <Output extends ts.ConciseBody>(
+    config: Pick<
+      FeatureProgrammer.IConfig<Output>,
+      "decoder" | "path" | "trace"
+    >,
+  ) =>
+  (importer: FunctionImporter) =>
+  (obj: MetadataObject) =>
+  (input: ts.Expression, from: "object" | "top" | "array" = "object") =>
+    obj.properties.map((prop) => {
+      const sole: string | null = prop.key.getSoleLiteral();
+      const propInput =
+        sole === null
+          ? ts.factory.createIdentifier("value")
+          : Escaper.variable(sole)
+            ? ts.factory.createPropertyAccessExpression(
+                input,
+                ts.factory.createIdentifier(sole),
+              )
+            : ts.factory.createElementAccessExpression(
+                input,
+                ts.factory.createStringLiteral(sole),
+              );
+
+      return {
+        input: propInput,
+        key: prop.key,
+        meta: prop.value,
+        expression: config.decoder()(propInput, prop.value, {
+          tracable: config.path || config.trace,
+          source: "function",
+          from,
+          postfix: config.trace
+            ? sole !== null
+              ? IdentifierFactory.postfix(sole)
+              : (() => {
+                  importer.use("join");
+                  return `$join(key)`;
+                })()
+            : "",
+        }),
+      };
+    });

package/src/programmers/internal/llm_schema_array.ts

@@ -1,22 +1,22 @@
-import { ILlmSchema } from "@samchon/openapi";
-
-import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-
-import { application_plugin } from "./application_plugin";
-import { llm_schema_station } from "./llm_schema_station";
-
-/**
- * @internal
- */
-export const llm_schema_array = (array: MetadataArray): ILlmSchema.IArray[] =>
-  application_plugin(
-    {
-      type: "array",
-      items: llm_schema_station({
-        metadata: array.type.value,
-        blockNever: false,
-        attribute: {},
-      }),
-    },
-    array.tags,
-  );
+import { ILlmSchema } from "@samchon/openapi";
+
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+
+import { application_plugin } from "./application_plugin";
+import { llm_schema_station } from "./llm_schema_station";
+
+/**
+ * @internal
+ */
+export const llm_schema_array = (array: MetadataArray): ILlmSchema.IArray[] =>
+  application_plugin(
+    {
+      type: "array",
+      items: llm_schema_station({
+        metadata: array.type.value,
+        blockNever: false,
+        attribute: {},
+      }),
+    },
+    array.tags,
+  );

package/src/programmers/internal/llm_schema_escaped.ts

@@ -1,61 +1,61 @@
-import { ILlmSchema } from "@samchon/openapi";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
-
-import { llm_schema_station } from "./llm_schema_station";
-
-/**
- * @internal
- */
-export const llm_schema_escaped = (escaped: MetadataEscaped): ILlmSchema[] => {
-  const output: ILlmSchema | null = llm_schema_station({
-    metadata: escaped.returns,
-    blockNever: false,
-    attribute: {},
-  });
-  if (output === null) return [];
-  else if (is_date(new Set())(escaped.original)) {
-    const string: ILlmSchema.IString | undefined = is_string(output)
-      ? output
-      : is_one_of(output)
-        ? (output.oneOf.find(is_string) as ILlmSchema.IString)
-        : undefined;
-    if (
-      string !== undefined &&
-      string.format !== "date" &&
-      string.format !== "date-time"
-    )
-      string.format = "date-time";
-  }
-  return is_one_of(output) ? (output.oneOf as ILlmSchema[]) : [output];
-};
-
-/**
- * @internal
- */
-const is_string = (elem: ILlmSchema): elem is ILlmSchema.IString =>
-  (elem as ILlmSchema.IString).type === "string";
-
-/**
- * @internal
- */
-const is_one_of = (elem: ILlmSchema): elem is ILlmSchema.IOneOf =>
-  Array.isArray((elem as ILlmSchema.IOneOf).oneOf);
-
-/**
- * @internal
- */
-const is_date =
-  (visited: Set<Metadata>) =>
-  (meta: Metadata): boolean => {
-    if (visited.has(meta)) return false;
-    visited.add(meta);
-
-    return (
-      meta.natives.some((name) => name === "Date") ||
-      meta.arrays.some((array) => is_date(visited)(array.type.value)) ||
-      meta.tuples.some((tuple) => tuple.type.elements.some(is_date(visited))) ||
-      meta.aliases.some((alias) => is_date(visited)(alias.value))
-    );
-  };
+import { ILlmSchema } from "@samchon/openapi";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
+
+import { llm_schema_station } from "./llm_schema_station";
+
+/**
+ * @internal
+ */
+export const llm_schema_escaped = (escaped: MetadataEscaped): ILlmSchema[] => {
+  const output: ILlmSchema | null = llm_schema_station({
+    metadata: escaped.returns,
+    blockNever: false,
+    attribute: {},
+  });
+  if (output === null) return [];
+  else if (is_date(new Set())(escaped.original)) {
+    const string: ILlmSchema.IString | undefined = is_string(output)
+      ? output
+      : is_one_of(output)
+        ? (output.oneOf.find(is_string) as ILlmSchema.IString)
+        : undefined;
+    if (
+      string !== undefined &&
+      string.format !== "date" &&
+      string.format !== "date-time"
+    )
+      string.format = "date-time";
+  }
+  return is_one_of(output) ? (output.oneOf as ILlmSchema[]) : [output];
+};
+
+/**
+ * @internal
+ */
+const is_string = (elem: ILlmSchema): elem is ILlmSchema.IString =>
+  (elem as ILlmSchema.IString).type === "string";
+
+/**
+ * @internal
+ */
+const is_one_of = (elem: ILlmSchema): elem is ILlmSchema.IOneOf =>
+  Array.isArray((elem as ILlmSchema.IOneOf).oneOf);
+
+/**
+ * @internal
+ */
+const is_date =
+  (visited: Set<Metadata>) =>
+  (meta: Metadata): boolean => {
+    if (visited.has(meta)) return false;
+    visited.add(meta);
+
+    return (
+      meta.natives.some((name) => name === "Date") ||
+      meta.arrays.some((array) => is_date(visited)(array.type.value)) ||
+      meta.tuples.some((tuple) => tuple.type.elements.some(is_date(visited))) ||
+      meta.aliases.some((alias) => is_date(visited)(alias.value))
+    );
+  };

package/src/programmers/internal/llm_schema_native.ts

@@ -1,17 +1,17 @@
-import { ILlmSchema } from "@samchon/openapi";
-
-/**
- * @internal
- */
-export const llm_schema_native = (
-  name: string,
-): ILlmSchema.IString | ILlmSchema.IObject =>
-  name === "Blob" || name === "File"
-    ? {
-        type: "string",
-        format: "binary",
-      }
-    : {
-        type: "object",
-        properties: {},
-      };
+import { ILlmSchema } from "@samchon/openapi";
+
+/**
+ * @internal
+ */
+export const llm_schema_native = (
+  name: string,
+): ILlmSchema.IString | ILlmSchema.IObject =>
+  name === "Blob" || name === "File"
+    ? {
+        type: "string",
+        format: "binary",
+      }
+    : {
+        type: "object",
+        properties: {},
+      };