typia 5.5.7 → 5.5.8

package/src/programmers/AssertProgrammer.ts

@@ -37,48 +37,50 @@ export namespace AssertProgrammer {
             ...(entry.conditions.length === 0
               ? []
               : entry.conditions.length === 1
-              ? entry.conditions[0]!.map((cond) =>
-                  ts.factory.createLogicalOr(
-                    cond.expression,
-                    create_guard_call(importer)(
-                      explore.from === "top"
-                        ? ts.factory.createTrue()
-                        : ts.factory.createIdentifier("_exceptionable"),
-                    )(
-                      ts.factory.createIdentifier(
-                        explore.postfix
-                          ? `_path + ${explore.postfix}`
-                          : "_path",
+                ? entry.conditions[0]!.map((cond) =>
+                    ts.factory.createLogicalOr(
+                      cond.expression,
+                      create_guard_call(importer)(
+                        explore.from === "top"
+                          ? ts.factory.createTrue()
+                          : ts.factory.createIdentifier("_exceptionable"),
+                      )(
+                        ts.factory.createIdentifier(
+                          explore.postfix
+                            ? `_path + ${explore.postfix}`
+                            : "_path",
+                        ),
+                        cond.expected,
+                        input,
                       ),
-                      cond.expected,
-                      input,
                     ),
-                  ),
-                )
-              : [
-                  ts.factory.createLogicalOr(
-                    entry.conditions
-                      .map((set) =>
-                        set
-                          .map((s) => s.expression)
-                          .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
-                      )
-                      .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-                    create_guard_call(importer)(
-                      explore.from === "top"
-                        ? ts.factory.createTrue()
-                        : ts.factory.createIdentifier("_exceptionable"),
-                    )(
-                      ts.factory.createIdentifier(
-                        explore.postfix
-                          ? `_path + ${explore.postfix}`
-                          : "_path",
+                  )
+                : [
+                    ts.factory.createLogicalOr(
+                      entry.conditions
+                        .map((set) =>
+                          set
+                            .map((s) => s.expression)
+                            .reduce((a, b) =>
+                              ts.factory.createLogicalAnd(a, b),
+                            ),
+                        )
+                        .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+                      create_guard_call(importer)(
+                        explore.from === "top"
+                          ? ts.factory.createTrue()
+                          : ts.factory.createIdentifier("_exceptionable"),
+                      )(
+                        ts.factory.createIdentifier(
+                          explore.postfix
+                            ? `_path + ${explore.postfix}`
+                            : "_path",
+                        ),
+                        entry.expected,
+                        input,
                       ),
-                      entry.expected,
-                      input,
                     ),
-                  ),
-                ]),
+                  ]),
           ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
         combiner: combiner(props.equals)(project)(importer),
         joiner: joiner(props.equals)(project)(importer),

package/src/programmers/CheckerProgrammer.ts

@@ -18,6 +18,7 @@ import { IProject } from "../transformers/IProject";
 import { TransformerError } from "../transformers/TransformerError";
 
 import { FeatureProgrammer } from "./FeatureProgrammer";
+import { IsProgrammer } from "./IsProgrammer";
 import { AtomicPredicator } from "./helpers/AtomicPredicator";
 import { FunctionImporter } from "./helpers/FunctionImporter";
 import { ICheckEntry } from "./helpers/ICheckEntry";
@@ -32,7 +33,6 @@ import { check_string } from "./internal/check_string";
 import { check_template } from "./internal/check_template";
 import { decode_union_object } from "./internal/decode_union_object";
 import { wrap_metadata_rest_tuple } from "./internal/wrap_metadata_rest_tuple";
-import { IsProgrammer } from "./IsProgrammer";
 
 export namespace CheckerProgrammer {
   export interface IConfig {
@@ -596,8 +596,8 @@ export namespace CheckerProgrammer {
             meta.getName(),
           )
         : binaries.length
-        ? config.combiner(explore)("or")(input, binaries, meta.getName())
-        : config.success;
+          ? config.combiner(explore)("or")(input, binaries, meta.getName())
+          : config.success;
     };
 
   export const decode_object =

package/src/programmers/FeatureProgrammer.ts

@@ -406,33 +406,33 @@ export namespace FeatureProgrammer {
         config.path === false && config.trace === false
           ? []
           : config.path === true && config.trace === true
-          ? [
-              ts.factory.createIdentifier(
-                explore.postfix ? `_path + ${explore.postfix}` : "_path",
-              ),
-              explore.source === "function"
-                ? ts.factory.createIdentifier(
-                    `${explore.tracable} && _exceptionable`,
-                  )
-                : explore.tracable
-                ? ts.factory.createTrue()
-                : ts.factory.createFalse(),
-            ]
-          : config.path === true
-          ? [
-              ts.factory.createIdentifier(
-                explore.postfix ? `_path + ${explore.postfix}` : "_path",
-              ),
-            ]
-          : [
-              explore.source === "function"
-                ? ts.factory.createIdentifier(
-                    `${explore.tracable} && _exceptionable`,
-                  )
-                : explore.tracable
-                ? ts.factory.createTrue()
-                : ts.factory.createFalse(),
-            ];
+            ? [
+                ts.factory.createIdentifier(
+                  explore.postfix ? `_path + ${explore.postfix}` : "_path",
+                ),
+                explore.source === "function"
+                  ? ts.factory.createIdentifier(
+                      `${explore.tracable} && _exceptionable`,
+                    )
+                  : explore.tracable
+                    ? ts.factory.createTrue()
+                    : ts.factory.createFalse(),
+              ]
+            : config.path === true
+              ? [
+                  ts.factory.createIdentifier(
+                    explore.postfix ? `_path + ${explore.postfix}` : "_path",
+                  ),
+                ]
+              : [
+                  explore.source === "function"
+                    ? ts.factory.createIdentifier(
+                        `${explore.tracable} && _exceptionable`,
+                      )
+                    : explore.tracable
+                      ? ts.factory.createTrue()
+                      : ts.factory.createFalse(),
+                ];
       return (input: ts.Expression) => [input, ...tail];
     };
 

package/src/programmers/RandomProgrammer.ts

@@ -305,10 +305,10 @@ export namespace RandomProgrammer {
     typeof value === "boolean"
       ? ts.factory.createIdentifier(value.toString())
       : typeof value === "number"
-      ? ExpressionFactory.number(value)
-      : typeof value === "string"
-      ? ts.factory.createStringLiteral(value)
-      : ExpressionFactory.bigint(Number(value));
+        ? ExpressionFactory.number(value)
+        : typeof value === "string"
+          ? ts.factory.createStringLiteral(value)
+          : ExpressionFactory.bigint(Number(value));
 
   const decode_template =
     (importer: FunctionImporter) =>
@@ -328,12 +328,12 @@ export namespace RandomProgrammer {
         )
           ? "int"
           : tags.find(
-              (t) =>
-                t.kind === "type" &&
-                (t.value === "uint32" || t.value === "uint64"),
-            )
-          ? "uint"
-          : "double";
+                (t) =>
+                  t.kind === "type" &&
+                  (t.value === "uint32" || t.value === "uint64"),
+              )
+            ? "uint"
+            : "double";
         const multiply = tags.find((t) => t.kind === "multipleOf");
         return random_custom(COALESCE(importer))("number")(tags)(
           RandomRanger.number({
@@ -706,8 +706,8 @@ export namespace RandomProgrammer {
                     type === "Float32Array" || type === "Float64Array"
                       ? "number"
                       : type === "BigInt64Array" || type === "BigUint64Array"
-                      ? "bigint"
-                      : "integer",
+                        ? "bigint"
+                        : "integer",
                   ),
                   undefined,
                   [literal(minimum), literal(maximum)],

package/src/programmers/TypiaProgrammer.ts

@@ -89,12 +89,12 @@ export namespace TypiaProgrammer {
         diag.category === ts.DiagnosticCategory.Warning
           ? "warning"
           : diag.category === ts.DiagnosticCategory.Error
-          ? "error"
-          : diag.category === ts.DiagnosticCategory.Suggestion
-          ? "suggestion"
-          : diag.category === ts.DiagnosticCategory.Message
-          ? "message"
-          : "unkown";
+            ? "error"
+            : diag.category === ts.DiagnosticCategory.Suggestion
+              ? "suggestion"
+              : diag.category === ts.DiagnosticCategory.Message
+                ? "message"
+                : "unkown";
       const [line, pos] = diag.file
         ? (() => {
             const lines: string[] = diag

package/src/programmers/ValidateProgrammer.ts

@@ -38,48 +38,50 @@ export namespace ValidateProgrammer {
             ...(entry.conditions.length === 0
               ? []
               : entry.conditions.length === 1
-              ? entry.conditions[0]!.map((cond) =>
-                  ts.factory.createLogicalOr(
-                    cond.expression,
-                    create_report_call(
-                      explore.from === "top"
-                        ? ts.factory.createTrue()
-                        : ts.factory.createIdentifier("_exceptionable"),
-                    )(
-                      ts.factory.createIdentifier(
-                        explore.postfix
-                          ? `_path + ${explore.postfix}`
-                          : "_path",
+                ? entry.conditions[0]!.map((cond) =>
+                    ts.factory.createLogicalOr(
+                      cond.expression,
+                      create_report_call(
+                        explore.from === "top"
+                          ? ts.factory.createTrue()
+                          : ts.factory.createIdentifier("_exceptionable"),
+                      )(
+                        ts.factory.createIdentifier(
+                          explore.postfix
+                            ? `_path + ${explore.postfix}`
+                            : "_path",
+                        ),
+                        cond.expected,
+                        input,
                       ),
-                      cond.expected,
-                      input,
                     ),
-                  ),
-                )
-              : [
-                  ts.factory.createLogicalOr(
-                    entry.conditions
-                      .map((set) =>
-                        set
-                          .map((s) => s.expression)
-                          .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
-                      )
-                      .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-                    create_report_call(
-                      explore.from === "top"
-                        ? ts.factory.createTrue()
-                        : ts.factory.createIdentifier("_exceptionable"),
-                    )(
-                      ts.factory.createIdentifier(
-                        explore.postfix
-                          ? `_path + ${explore.postfix}`
-                          : "_path",
+                  )
+                : [
+                    ts.factory.createLogicalOr(
+                      entry.conditions
+                        .map((set) =>
+                          set
+                            .map((s) => s.expression)
+                            .reduce((a, b) =>
+                              ts.factory.createLogicalAnd(a, b),
+                            ),
+                        )
+                        .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+                      create_report_call(
+                        explore.from === "top"
+                          ? ts.factory.createTrue()
+                          : ts.factory.createIdentifier("_exceptionable"),
+                      )(
+                        ts.factory.createIdentifier(
+                          explore.postfix
+                            ? `_path + ${explore.postfix}`
+                            : "_path",
+                        ),
+                        entry.expected,
+                        input,
                       ),
-                      entry.expected,
-                      input,
                     ),
-                  ),
-                ]),
+                  ]),
           ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
         combiner: combine(equals)(project)(importer),
         joiner: joiner(equals)(project)(importer),

package/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts

@@ -1,130 +1,130 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { StringUtil } from "../../utils/StringUtil";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionalAssertParametersProgrammer } from "./FunctionalAssertParametersProgrammer";
-import { FunctionAssertReturnProgrammer } from "./FunctionalAssertReturnProgrammer";
-
-export namespace FunctionalAssertFunctionProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-      init?: ts.Expression,
-    ): ts.ArrowFunction => {
-      const wrapper = errorFactoryWrapper(modulo)(declaration.parameters)(init);
-      const { async, returns } = FunctionAssertReturnProgrammer.returnStatement(
-        project,
-      )(modulo)(equals)(expression, declaration, wrapper.name);
-      return ts.factory.createArrowFunction(
-        async
-          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-          : undefined,
-        undefined,
-        declaration.parameters,
-        declaration.type,
-        undefined,
-        ts.factory.createBlock([
-          wrapper.variable,
-          ...FunctionalAssertParametersProgrammer.argumentExpressions(project)(
-            modulo,
-          )(equals)(declaration.parameters, wrapper.name).map(
-            ts.factory.createExpressionStatement,
-          ),
-          returns,
-        ]),
-      );
-    };
-
-  export const errorFactoryWrapper =
-    (modulo: ts.LeftHandSideExpression) =>
-    (paramters: readonly ts.ParameterDeclaration[]) =>
-    (
-      init: ts.Expression | undefined,
-    ): {
-      name: string;
-      variable: ts.VariableStatement;
-    } => {
-      const name: string = StringUtil.escapeDuplicate(
-        paramters.map((p) => p.name.getText()),
-      )("errorFactoryWrapper");
-      const variable: ts.VariableStatement = ts.factory.createVariableStatement(
-        undefined,
-        ts.factory.createVariableDeclarationList(
-          [
-            ts.factory.createVariableDeclaration(
-              name,
-              undefined,
-              AssertProgrammer.Guardian.type(),
-              init ??
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createAsExpression(
-                    modulo,
-                    TypeFactory.keyword("any"),
-                  ),
-                  "errorFactory",
-                ),
-            ),
-          ],
-          ts.NodeFlags.Const,
-        ),
-      );
-      return { name, variable };
-    };
-
-  export const hookPath = (props: {
-    wrapper: string;
-    replacer: string;
-  }): ts.ArrowFunction =>
-    ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [IdentifierFactory.parameter("p")],
-      undefined,
-      undefined,
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier(props.wrapper),
-        undefined,
-        [
-          ts.factory.createObjectLiteralExpression([
-            ts.factory.createSpreadAssignment(ts.factory.createIdentifier("p")),
-            ts.factory.createPropertyAssignment(
-              "path",
-              ts.factory.createConditionalExpression(
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createIdentifier("p"),
-                  "path",
-                ),
-                undefined,
-                ts.factory.createCallExpression(
-                  ts.factory.createPropertyAccessExpression(
-                    ts.factory.createPropertyAccessExpression(
-                      ts.factory.createIdentifier("p"),
-                      "path",
-                    ),
-                    "replace",
-                  ),
-                  undefined,
-                  [
-                    ts.factory.createStringLiteral("$input"),
-                    ts.factory.createStringLiteral(props.replacer),
-                  ],
-                ),
-                undefined,
-                ts.factory.createIdentifier("undefined"),
-              ),
-            ),
-          ]),
-        ],
-      ),
-    );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { StringUtil } from "../../utils/StringUtil";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionalAssertParametersProgrammer } from "./FunctionalAssertParametersProgrammer";
+import { FunctionAssertReturnProgrammer } from "./FunctionalAssertReturnProgrammer";
+
+export namespace FunctionalAssertFunctionProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+      init?: ts.Expression,
+    ): ts.ArrowFunction => {
+      const wrapper = errorFactoryWrapper(modulo)(declaration.parameters)(init);
+      const { async, returns } = FunctionAssertReturnProgrammer.returnStatement(
+        project,
+      )(modulo)(equals)(expression, declaration, wrapper.name);
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        declaration.type,
+        undefined,
+        ts.factory.createBlock([
+          wrapper.variable,
+          ...FunctionalAssertParametersProgrammer.argumentExpressions(project)(
+            modulo,
+          )(equals)(declaration.parameters, wrapper.name).map(
+            ts.factory.createExpressionStatement,
+          ),
+          returns,
+        ]),
+      );
+    };
+
+  export const errorFactoryWrapper =
+    (modulo: ts.LeftHandSideExpression) =>
+    (paramters: readonly ts.ParameterDeclaration[]) =>
+    (
+      init: ts.Expression | undefined,
+    ): {
+      name: string;
+      variable: ts.VariableStatement;
+    } => {
+      const name: string = StringUtil.escapeDuplicate(
+        paramters.map((p) => p.name.getText()),
+      )("errorFactoryWrapper");
+      const variable: ts.VariableStatement = ts.factory.createVariableStatement(
+        undefined,
+        ts.factory.createVariableDeclarationList(
+          [
+            ts.factory.createVariableDeclaration(
+              name,
+              undefined,
+              AssertProgrammer.Guardian.type(),
+              init ??
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createAsExpression(
+                    modulo,
+                    TypeFactory.keyword("any"),
+                  ),
+                  "errorFactory",
+                ),
+            ),
+          ],
+          ts.NodeFlags.Const,
+        ),
+      );
+      return { name, variable };
+    };
+
+  export const hookPath = (props: {
+    wrapper: string;
+    replacer: string;
+  }): ts.ArrowFunction =>
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("p")],
+      undefined,
+      undefined,
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier(props.wrapper),
+        undefined,
+        [
+          ts.factory.createObjectLiteralExpression([
+            ts.factory.createSpreadAssignment(ts.factory.createIdentifier("p")),
+            ts.factory.createPropertyAssignment(
+              "path",
+              ts.factory.createConditionalExpression(
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createIdentifier("p"),
+                  "path",
+                ),
+                undefined,
+                ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createPropertyAccessExpression(
+                      ts.factory.createIdentifier("p"),
+                      "path",
+                    ),
+                    "replace",
+                  ),
+                  undefined,
+                  [
+                    ts.factory.createStringLiteral("$input"),
+                    ts.factory.createStringLiteral(props.replacer),
+                  ],
+                ),
+                undefined,
+                ts.factory.createIdentifier("undefined"),
+              ),
+            ),
+          ]),
+        ],
+      ),
+    );
+}