typia 6.10.0 → 6.10.1-dev.20240919

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/metadata_to_pattern.ts

@@ -1,34 +1,34 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { PatternUtil } from "../../utils/PatternUtil";
-
-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 "(.*)";
-
-    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 pattern: string =
-      values.length === 1 ? values[0]! : "(" + values.join("|") + ")";
-    return top ? PatternUtil.fix(pattern) : pattern;
-  };
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { PatternUtil } from "../../utils/PatternUtil";
+
+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 "(.*)";
+
+    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 pattern: string =
+      values.length === 1 ? values[0]! : "(" + values.join("|") + ")";
+    return top ? PatternUtil.fix(pattern) : pattern;
+  };

package/src/programmers/internal/postfix_of_tuple.ts

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

package/src/programmers/internal/prune_object_properties.ts

@@ -1,60 +1,60 @@
-import ts from "typescript";
-
-import { StatementFactory } from "../../factories/StatementFactory";
-
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export const prune_object_properties = (obj: 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 name: string | null = prop.key.getSoleLiteral();
-    if (name !== null)
-      return ts.factory.createStrictEquality(
-        ts.factory.createStringLiteral(name),
-        ts.factory.createIdentifier("key"),
-      );
-    return ts.factory.createCallExpression(
-      ts.factory.createIdentifier(
-        `RegExp(/${metadata_to_pattern(true)(prop.key)}/).test`,
-      ),
-      undefined,
-      [key],
-    );
-  });
-
-  const statements: ts.Statement[] = [];
-  if (condition.length)
-    statements.push(
-      ts.factory.createIfStatement(
-        condition.reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-        ts.factory.createContinueStatement(),
-      ),
-    );
-  statements.push(
-    ts.factory.createExpressionStatement(
-      ts.factory.createDeleteExpression(
-        ts.factory.createElementAccessExpression(input, key),
-      ),
-    ),
-  );
-
-  return ts.factory.createForOfStatement(
-    undefined,
-    StatementFactory.constant("key").declarationList,
-    ts.factory.createCallExpression(
-      ts.factory.createIdentifier("Object.keys"),
-      undefined,
-      [input],
-    ),
-    statements.length === 1
-      ? statements[0]!
-      : ts.factory.createBlock(statements, true),
-  );
-};
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const prune_object_properties = (obj: 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 name: string | null = prop.key.getSoleLiteral();
+    if (name !== null)
+      return ts.factory.createStrictEquality(
+        ts.factory.createStringLiteral(name),
+        ts.factory.createIdentifier("key"),
+      );
+    return ts.factory.createCallExpression(
+      ts.factory.createIdentifier(
+        `RegExp(/${metadata_to_pattern(true)(prop.key)}/).test`,
+      ),
+      undefined,
+      [key],
+    );
+  });
+
+  const statements: ts.Statement[] = [];
+  if (condition.length)
+    statements.push(
+      ts.factory.createIfStatement(
+        condition.reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+        ts.factory.createContinueStatement(),
+      ),
+    );
+  statements.push(
+    ts.factory.createExpressionStatement(
+      ts.factory.createDeleteExpression(
+        ts.factory.createElementAccessExpression(input, key),
+      ),
+    ),
+  );
+
+  return ts.factory.createForOfStatement(
+    undefined,
+    StatementFactory.constant("key").declarationList,
+    ts.factory.createCallExpression(
+      ts.factory.createIdentifier("Object.keys"),
+      undefined,
+      [input],
+    ),
+    statements.length === 1
+      ? statements[0]!
+      : ts.factory.createBlock(statements, true),
+  );
+};

package/src/programmers/internal/random_custom.ts

@@ -1,37 +1,37 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { LiteralFactory } from "../../factories/LiteralFactory";
-
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-
-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),
-        ),
-        ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-        undefined,
-        [
-          LiteralFactory.generate(
-            tags.map((t) => ({
-              name: t.name,
-              kind: t.kind,
-              value: t.value,
-            })),
-          ),
-        ],
-      ),
-    )(expression);
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { LiteralFactory } from "../../factories/LiteralFactory";
+
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+
+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),
+        ),
+        ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+        undefined,
+        [
+          LiteralFactory.generate(
+            tags.map((t) => ({
+              name: t.name,
+              kind: t.kind,
+              value: t.value,
+            })),
+          ),
+        ],
+      ),
+    )(expression);