typia 7.0.0-dev.20241011 → 7.0.0-dev.20241012

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 { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+
+/**
+ * @internal
+ */
+export const decode_union_object = (props: {
+  checker: (next: {
+    input: ts.Expression;
+    object: MetadataObjectType;
+    explore: FeatureProgrammer.IExplore;
+  }) => ts.Expression;
+  decoder: (next: {
+    input: ts.Expression;
+    object: MetadataObjectType;
+    explore: FeatureProgrammer.IExplore;
+  }) => ts.Expression;
+  success: (exp: ts.Expression) => ts.Expression;
+  escaper: (next: { input: ts.Expression; expected: string }) => ts.Statement;
+  objects: MetadataObjectType[];
+  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

@@ -2,7 +2,7 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 
 import { ITypiaContext } from "../../transformers/ITypiaContext";
 
@@ -16,7 +16,7 @@ import { FeatureProgrammer } from "../FeatureProgrammer";
 export const feature_object_entries = <Output extends ts.ConciseBody>(props: {
   config: Pick<FeatureProgrammer.IConfig<Output>, "decoder" | "path" | "trace">;
   context: ITypiaContext;
-  object: MetadataObject;
+  object: MetadataObjectType;
   input: ts.Expression;
   from?: "object" | "top" | "array";
 }) =>

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,
+      }),
+    )
+  );
+};