typia 7.0.0-dev.20241005 → 7.0.0-dev.20241007

package/src/programmers/internal/decode_union_object.ts

@@ -1,116 +1,116 @@
-import ts from "typescript";
-
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-
-/**
- * @internal
- */
-export const decode_union_object = (props: {
-  checker: (next: {
-    input: ts.Expression;
-    object: MetadataObject;
-    explore: FeatureProgrammer.IExplore;
-  }) => ts.Expression;
-  decoder: (next: {
-    input: ts.Expression;
-    object: MetadataObject;
-    explore: FeatureProgrammer.IExplore;
-  }) => ts.Expression;
-  success: (exp: ts.Expression) => ts.Expression;
-  escaper: (next: { input: ts.Expression; expected: string }) => ts.Statement;
-  objects: MetadataObject[];
-  input: ts.Expression;
-  explore: FeatureProgrammer.IExplore;
-}): ts.CallExpression =>
-  ts.factory.createCallExpression(
-    ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [],
-      undefined,
-      undefined,
-      iterate({
-        escaper: props.escaper,
-        input: props.input,
-        unions: props.objects.map((object) => ({
-          type: "object",
-          is: () =>
-            props.success(
-              props.checker({
-                input: props.input,
-                explore: props.explore,
-                object,
-              }),
-            ),
-          value: () =>
-            props.decoder({
-              input: props.input,
-              explore: props.explore,
-              object,
-            }),
-        })),
-        expected: `(${props.objects.map((t) => t.name).join(" | ")})`,
-      }),
-    ),
-    undefined,
-    undefined,
-  );
-
-/**
- * @internal
- */
-const iterate = (props: {
-  escaper: (next: { input: ts.Expression; expected: string }) => ts.Statement;
-  unions: IUnion[];
-  expected: string;
-  input: ts.Expression;
-}) => {
-  interface IBranch {
-    condition: null | ts.Expression;
-    value: ts.Expression;
-  }
-  const branches: IBranch[] = [];
-
-  for (const u of props.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([props.escaper(props)], 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(props.escaper(props));
-  return ts.factory.createBlock(statements, true);
-};
-
-/**
- * @internal
- */
-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 = (props: {
+  checker: (next: {
+    input: ts.Expression;
+    object: MetadataObject;
+    explore: FeatureProgrammer.IExplore;
+  }) => ts.Expression;
+  decoder: (next: {
+    input: ts.Expression;
+    object: MetadataObject;
+    explore: FeatureProgrammer.IExplore;
+  }) => ts.Expression;
+  success: (exp: ts.Expression) => ts.Expression;
+  escaper: (next: { input: ts.Expression; expected: string }) => ts.Statement;
+  objects: MetadataObject[];
+  input: ts.Expression;
+  explore: FeatureProgrammer.IExplore;
+}): ts.CallExpression =>
+  ts.factory.createCallExpression(
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [],
+      undefined,
+      undefined,
+      iterate({
+        escaper: props.escaper,
+        input: props.input,
+        unions: props.objects.map((object) => ({
+          type: "object",
+          is: () =>
+            props.success(
+              props.checker({
+                input: props.input,
+                explore: props.explore,
+                object,
+              }),
+            ),
+          value: () =>
+            props.decoder({
+              input: props.input,
+              explore: props.explore,
+              object,
+            }),
+        })),
+        expected: `(${props.objects.map((t) => t.name).join(" | ")})`,
+      }),
+    ),
+    undefined,
+    undefined,
+  );
+
+/**
+ * @internal
+ */
+const iterate = (props: {
+  escaper: (next: { input: ts.Expression; expected: string }) => ts.Statement;
+  unions: IUnion[];
+  expected: string;
+  input: ts.Expression;
+}) => {
+  interface IBranch {
+    condition: null | ts.Expression;
+    value: ts.Expression;
+  }
+  const branches: IBranch[] = [];
+
+  for (const u of props.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([props.escaper(props)], 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(props.escaper(props));
+  return ts.factory.createBlock(statements, true);
+};
+
+/**
+ * @internal
+ */
+interface IUnion {
+  type: string;
+  is: () => ts.Expression;
+  value: () => ts.Expression;
+}

package/src/programmers/internal/feature_object_entries.ts

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

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({
-    schema: {
-      type: "array",
-      items: llm_schema_station({
-        metadata: array.type.value,
-        blockNever: false,
-        attribute: {},
-      }),
-    },
-    tags: 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({
+    schema: {
+      type: "array",
+      items: llm_schema_station({
+        metadata: array.type.value,
+        blockNever: false,
+        attribute: {},
+      }),
+    },
+    tags: array.tags,
+  });

package/src/programmers/internal/llm_schema_escaped.ts

@@ -1,84 +1,84 @@
-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({
-      visited: new Set(),
-      metadata: 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 = (props: {
-  visited: Set<Metadata>;
-  metadata: Metadata;
-}): boolean => {
-  if (props.visited.has(props.metadata)) return false;
-  props.visited.add(props.metadata);
-
-  return (
-    props.metadata.natives.some((name) => name === "Date") ||
-    props.metadata.arrays.some((array) =>
-      is_date({
-        visited: props.visited,
-        metadata: array.type.value,
-      }),
-    ) ||
-    props.metadata.tuples.some((tuple) =>
-      tuple.type.elements.some((elem) =>
-        is_date({
-          visited: props.visited,
-          metadata: elem,
-        }),
-      ),
-    ) ||
-    props.metadata.aliases.some((alias) =>
-      is_date({
-        visited: props.visited,
-        metadata: 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({
+      visited: new Set(),
+      metadata: 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 = (props: {
+  visited: Set<Metadata>;
+  metadata: Metadata;
+}): boolean => {
+  if (props.visited.has(props.metadata)) return false;
+  props.visited.add(props.metadata);
+
+  return (
+    props.metadata.natives.some((name) => name === "Date") ||
+    props.metadata.arrays.some((array) =>
+      is_date({
+        visited: props.visited,
+        metadata: array.type.value,
+      }),
+    ) ||
+    props.metadata.tuples.some((tuple) =>
+      tuple.type.elements.some((elem) =>
+        is_date({
+          visited: props.visited,
+          metadata: elem,
+        }),
+      ),
+    ) ||
+    props.metadata.aliases.some((alias) =>
+      is_date({
+        visited: props.visited,
+        metadata: 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: {},
+      };