typia 7.0.0-dev.20240930 → 7.0.0-dev.20241002

package/src/programmers/internal/decode_union_object.ts

@@ -7,91 +7,108 @@ 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(" | ")})`,
-        ),
-      ),
+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,
+  );
 
-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[] = [];
+/**
+ * @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 unions) {
-      const condition: ts.Expression = u.is();
-      if (condition.kind === ts.SyntaxKind.TrueKeyword) {
-        branches.push({
-          condition: null,
-          value: u.value(),
-        });
-        break;
-      }
+  for (const u of props.unions) {
+    const condition: ts.Expression = u.is();
+    if (condition.kind === ts.SyntaxKind.TrueKeyword) {
       branches.push({
-        condition,
+        condition: null,
         value: u.value(),
       });
+      break;
     }
-    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;
+    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(escaper(input, expected));
-    return ts.factory.createBlock(statements, true);
-  };
+  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;

package/src/programmers/internal/feature_object_entries.ts

@@ -12,50 +12,47 @@ 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) =>
-  (object: MetadataObject) =>
-  (input: ts.Expression, from: "object" | "top" | "array" = "object") =>
-    object.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 {
+export const feature_object_entries = <Output extends ts.ConciseBody>(props: {
+  config: Pick<FeatureProgrammer.IConfig<Output>, "decoder" | "path" | "trace">;
+  importer: FunctionImporter;
+  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,
-        key: prop.key,
-        meta: prop.value,
-        expression: config.decoder({
-          input: propInput,
-          metadata: prop.value,
-          explore: {
-            tracable: config.path || config.trace,
-            source: "function",
-            from,
-            postfix: config.trace
-              ? sole !== null
-                ? IdentifierFactory.postfix(sole)
-                : (() => {
-                    importer.use("join");
-                    return `$join(key)`;
-                  })()
-              : "",
-          },
-        }),
-      };
-    });
+        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.importer.use("join");
+                  return `$join(key)`;
+                })()
+            : "",
+        },
+      }),
+    };
+  });

package/src/programmers/internal/llm_schema_escaped.ts

@@ -15,7 +15,12 @@ export const llm_schema_escaped = (escaped: MetadataEscaped): ILlmSchema[] => {
     attribute: {},
   });
   if (output === null) return [];
-  else if (is_date(new Set())(escaped.original)) {
+  else if (
+    is_date({
+      visited: new Set(),
+      metadata: escaped.original,
+    })
+  ) {
     const string: ILlmSchema.IString | undefined = is_string(output)
       ? output
       : is_one_of(output)
@@ -46,16 +51,34 @@ const is_one_of = (elem: ILlmSchema): elem is ILlmSchema.IOneOf =>
 /**
  * @internal
  */
-const is_date =
-  (visited: Set<Metadata>) =>
-  (meta: Metadata): boolean => {
-    if (visited.has(meta)) return false;
-    visited.add(meta);
+const is_date = (props: {
+  visited: Set<Metadata>;
+  metadata: Metadata;
+}): boolean => {
+  if (props.visited.has(props.metadata)) return false;
+  props.visited.add(props.metadata);
 
-    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))
-    );
-  };
+  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_object.ts

@@ -72,7 +72,10 @@ export const llm_schema_object = (props: {
       properties[key] = schema;
       if (property.value.isRequired() === true) required.push(key);
     } else {
-      const pattern: string = metadata_to_pattern(true)(property.key);
+      const pattern: string = metadata_to_pattern({
+        top: true,
+        metadata: property.key,
+      });
       if (pattern === PatternUtil.STRING)
         extraMeta.additionalProperties = [property.value, schema];
       else extraMeta.patternProperties[pattern] = [property.value, schema];

package/src/programmers/internal/metadata_to_pattern.ts

@@ -7,28 +7,36 @@ import { template_to_pattern } from "./template_to_pattern";
 /**
  * @internal
  */
-export const metadata_to_pattern =
-  (top: boolean) =>
-  (meta: Metadata): string => {
-    if (meta.atomics.find((a) => a.type === "string") !== undefined)
-      return "(.*)";
+export const metadata_to_pattern = (props: {
+  top: boolean;
+  metadata: Metadata;
+}): string => {
+  if (props.metadata.atomics.find((a) => a.type === "string") !== undefined)
+    return "(.*)";
 
-    const values: string[] = meta.constants
-      .map((c) => {
-        if (c.type !== "string") return c.values.map((v) => v.toString());
-        return (c.values.map((v) => v.value) as string[]).map((str) =>
-          PatternUtil.escape(str),
-        );
-      })
-      .flat();
-    for (const a of meta.atomics)
-      if (a.type === "number" || a.type === "bigint")
-        values.push(PatternUtil.NUMBER);
-      else if (a.type === "boolean") values.push(PatternUtil.BOOLEAN);
-    for (const { row } of meta.templates)
-      values.push("(" + template_to_pattern(false)(row) + ")");
+  const values: string[] = props.metadata.constants
+    .map((c) => {
+      if (c.type !== "string") return c.values.map((v) => v.toString());
+      return (c.values.map((v) => v.value) as string[]).map((str) =>
+        PatternUtil.escape(str),
+      );
+    })
+    .flat();
+  for (const a of props.metadata.atomics)
+    if (a.type === "number" || a.type === "bigint")
+      values.push(PatternUtil.NUMBER);
+    else if (a.type === "boolean") values.push(PatternUtil.BOOLEAN);
+  for (const { row } of props.metadata.templates)
+    values.push(
+      "(" +
+        template_to_pattern({
+          top: false,
+          template: row,
+        }) +
+        ")",
+    );
 
-    const pattern: string =
-      values.length === 1 ? values[0]! : "(" + values.join("|") + ")";
-    return top ? PatternUtil.fix(pattern) : pattern;
-  };
+  const pattern: string =
+    values.length === 1 ? values[0]! : "(" + values.join("|") + ")";
+  return props.top ? PatternUtil.fix(pattern) : pattern;
+};

package/src/programmers/internal/postfix_of_tuple.ts

@@ -1,2 +1,5 @@
+/**
+ * @internal
+ */
 export const postfix_of_tuple = (str: string): string =>
   str.endsWith('"') ? str.slice(0, -1) : `${str} + "`;

package/src/programmers/internal/prune_object_properties.ts

@@ -9,11 +9,11 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
 /**
  * @internal
  */
-export const prune_object_properties = (obj: MetadataObject) => {
+export const prune_object_properties = (object: MetadataObject) => {
   const input: ts.Expression = ts.factory.createIdentifier("input");
   const key: ts.Expression = ts.factory.createIdentifier("key");
 
-  const condition: ts.Expression[] = obj.properties.map((prop) => {
+  const condition: ts.Expression[] = object.properties.map((prop) => {
     const name: string | null = prop.key.getSoleLiteral();
     if (name !== null)
       return ts.factory.createStrictEquality(
@@ -22,7 +22,10 @@ export const prune_object_properties = (obj: MetadataObject) => {
       );
     return ts.factory.createCallExpression(
       ts.factory.createIdentifier(
-        `RegExp(/${metadata_to_pattern(true)(prop.key)}/).test`,
+        `RegExp(/${metadata_to_pattern({
+          top: true,
+          metadata: prop.key,
+        })}/).test`,
       ),
       undefined,
       [key],
@@ -47,7 +50,7 @@ export const prune_object_properties = (obj: MetadataObject) => {
 
   return ts.factory.createForOfStatement(
     undefined,
-    StatementFactory.constant("key").declarationList,
+    StatementFactory.constant({ name: "key" }).declarationList,
     ts.factory.createCallExpression(
       ts.factory.createIdentifier("Object.keys"),
       undefined,

package/src/programmers/internal/random_custom.ts

@@ -10,28 +10,30 @@ import { Customizable } from "../../typings/Customizable";
 /**
  * @internal
  */
-export const random_custom =
-  (accessor: (name: string) => ts.Expression) =>
-  (type: keyof Customizable) =>
-  (tags: IMetadataTypeTag[]) =>
-  (expression: ts.Expression) =>
-    ExpressionFactory.coalesce(
-      ts.factory.createCallChain(
-        ts.factory.createPropertyAccessChain(
-          accessor("customs"),
-          ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-          ts.factory.createIdentifier(type),
-        ),
+export const random_custom = (props: {
+  accessor: (name: string) => ts.Expression;
+  type: keyof Customizable;
+  tags: IMetadataTypeTag[];
+  expression: ts.Expression;
+}) =>
+  ExpressionFactory.coalesce(
+    ts.factory.createCallChain(
+      ts.factory.createPropertyAccessChain(
+        props.accessor("customs"),
         ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-        undefined,
-        [
-          LiteralFactory.generate(
-            tags.map((t) => ({
-              name: t.name,
-              kind: t.kind,
-              value: t.value,
-            })),
-          ),
-        ],
+        ts.factory.createIdentifier(props.type),
       ),
-    )(expression);
+      ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+      undefined,
+      [
+        LiteralFactory.generate(
+          props.tags.map((t) => ({
+            name: t.name,
+            kind: t.kind,
+            value: t.value,
+          })),
+        ),
+      ],
+    ),
+    props.expression,
+  );