typia 5.2.5 → 5.2.6-dev.20231108

package/src/programmers/helpers/AtomicPredicator.ts

@@ -1,31 +1,31 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { Atomic } from "../../typings/Atomic";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
-export namespace AtomicPredicator {
-    export const constant =
-        (meta: Metadata) =>
-        (name: Atomic.Literal): boolean =>
-            !ArrayUtil.has(meta.atomics, (a) => a.type === name) &&
-            !ArrayUtil.has(
-                meta.natives,
-                (native) => native.toLowerCase() === name,
-            );
-
-    export const atomic =
-        (meta: Metadata) =>
-        (name: Atomic.Literal): boolean =>
-            !ArrayUtil.has(
-                meta.natives,
-                (native) => native.toLowerCase() === name,
-            );
-
-    export const native = (name: string) => LIKE.has(name.toLowerCase());
-
-    export const template = (meta: Metadata): boolean =>
-        !ArrayUtil.has(meta.atomics, (a) => a.type === "string");
-}
-
-const LIKE = new Set(["boolean", "bigint", "number", "string"]);
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { Atomic } from "../../typings/Atomic";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+export namespace AtomicPredicator {
+    export const constant =
+        (meta: Metadata) =>
+        (name: Atomic.Literal): boolean =>
+            !ArrayUtil.has(meta.atomics, (a) => a.type === name) &&
+            !ArrayUtil.has(
+                meta.natives,
+                (native) => native.toLowerCase() === name,
+            );
+
+    export const atomic =
+        (meta: Metadata) =>
+        (name: Atomic.Literal): boolean =>
+            !ArrayUtil.has(
+                meta.natives,
+                (native) => native.toLowerCase() === name,
+            );
+
+    export const native = (name: string) => LIKE.has(name.toLowerCase());
+
+    export const template = (meta: Metadata): boolean =>
+        !ArrayUtil.has(meta.atomics, (a) => a.type === "string");
+}
+
+const LIKE = new Set(["boolean", "bigint", "number", "string"]);

package/src/programmers/helpers/RandomJoiner.ts

@@ -1,5 +1,6 @@
 import ts from "typescript";
 
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
@@ -36,7 +37,7 @@ export namespace RandomJoiner {
             if (explore.recursive === false) return generator;
             return ts.factory.createConditionalExpression(
                 ts.factory.createGreaterThanEquals(
-                    ts.factory.createNumericLiteral(5),
+                    ExpressionFactory.number(5),
                     ts.factory.createIdentifier("_depth"),
                 ),
                 undefined,
@@ -99,7 +100,7 @@ export namespace RandomJoiner {
                         ? [
                               ts.factory.createIfStatement(
                                   ts.factory.createGreaterThanEquals(
-                                      ts.factory.createNumericLiteral(5),
+                                      ExpressionFactory.number(5),
                                       ts.factory.createIdentifier("_depth"),
                                   ),
                                   ts.factory.createBlock(properties, true),
@@ -137,10 +138,7 @@ export namespace RandomJoiner {
                 ts.factory.createCallExpression(
                     coalesce("integer"),
                     undefined,
-                    [
-                        ts.factory.createNumericLiteral(0),
-                        ts.factory.createNumericLiteral(3),
-                    ],
+                    [ExpressionFactory.number(0), ExpressionFactory.number(3)],
                 ),
             ]);
 }

package/src/programmers/helpers/RandomRanger.ts

@@ -1,5 +1,7 @@
 import ts from "typescript";
 
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
 import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 
 export namespace RandomRanger {
@@ -30,8 +32,8 @@ export namespace RandomRanger {
                 coalesce("integer"),
                 undefined,
                 [
-                    ts.factory.createNumericLiteral(props.minimum),
-                    ts.factory.createNumericLiteral(props.maximum),
+                    ExpressionFactory.number(props.minimum),
+                    ExpressionFactory.number(props.maximum),
                 ],
             );
         };

package/src/programmers/http/HttpHeadersProgrammer.ts

@@ -196,7 +196,7 @@ export namespace HttpHeadersProgrammer {
                     const access = IdentifierFactory.access(output)(key);
                     return ts.factory.createIfStatement(
                         ts.factory.createStrictEquality(
-                            ts.factory.createNumericLiteral(0),
+                            ExpressionFactory.number(0),
                             IdentifierFactory.access(access)("length"),
                         ),
                         ts.factory.createExpressionStatement(

package/src/programmers/internal/check_dynamic_key.ts

@@ -1,178 +1,178 @@
-import ts from "typescript";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { IProject } from "../../transformers/IProject";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { check_bigint } from "./check_bigint";
-import { check_number } from "./check_number";
-import { check_string } from "./check_string";
-import { check_template } from "./check_template";
-
-export const check_dynamic_key =
-    (project: IProject) =>
-    (importer: FunctionImporter) =>
-    (input: ts.Expression, metadata: Metadata): ts.Expression => {
-        // IF PURE STRING EXISTS, THEN SKIP VALIDATION
-        if (
-            (metadata.atomics.length !== 0 &&
-                metadata.atomics.some(
-                    (a) =>
-                        a.type === "string" &&
-                        a.tags.filter((row) =>
-                            row.every((t) => t.validate !== undefined),
-                        ).length === 0,
-                )) ||
-            (metadata.natives.length !== 0 &&
-                metadata.natives.some((type) => type === "String"))
-        )
-            return ts.factory.createTrue();
-
-        const conditions: ts.Expression[] = [];
-
-        // NULLISH COALESCING
-        if (metadata.nullable === true)
-            conditions.push(
-                ts.factory.createStrictEquality(
-                    ts.factory.createStringLiteral("null"),
-                    input,
-                ),
-            );
-        if (metadata.isRequired() === false)
-            conditions.push(
-                ts.factory.createStrictEquality(
-                    ts.factory.createStringLiteral("undefined"),
-                    input,
-                ),
-            );
-
-        // ATOMICS
-        for (const atom of metadata.atomics)
-            if (atom.type === "boolean")
-                conditions.push(
-                    ts.factory.createLogicalOr(
-                        ts.factory.createStrictEquality(
-                            ts.factory.createStringLiteral("false"),
-                            input,
-                        ),
-                        ts.factory.createStrictEquality(
-                            ts.factory.createStringLiteral("true"),
-                            input,
-                        ),
-                    ),
-                );
-            else if (atom.type === "bigint")
-                conditions.push(
-                    ts.factory.createLogicalAnd(
-                        ts.factory.createCallExpression(
-                            importer.use("is_bigint_string"),
-                            undefined,
-                            [input],
-                        ),
-                        atomist(
-                            check_bigint(project)(atom)(
-                                ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("BigInt"),
-                                    undefined,
-                                    [input],
-                                ),
-                            ),
-                        ),
-                    ),
-                );
-            else if (atom.type === "number")
-                conditions.push(
-                    atomist(
-                        check_number(project, true)(atom)(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("Number"),
-                                undefined,
-                                [input],
-                            ),
-                        ),
-                    ),
-                );
-            else conditions.push(atomist(check_string(project)(atom)(input)));
-
-        // CONSTANTS
-        for (const constant of metadata.constants)
-            for (const value of constant.values)
-                conditions.push(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createStringLiteral(String(value)),
-                        input,
-                    ),
-                );
-
-        // TEMPLATES
-        if (!!metadata.templates.length)
-            conditions.push(atomist(check_template(metadata.templates)(input)));
-
-        // NATIVES
-        for (const native of metadata.natives)
-            if (native === "Boolean")
-                conditions.push(
-                    ts.factory.createLogicalOr(
-                        ts.factory.createStrictEquality(
-                            ts.factory.createStringLiteral("false"),
-                            input,
-                        ),
-                        ts.factory.createStrictEquality(
-                            ts.factory.createStringLiteral("true"),
-                            input,
-                        ),
-                    ),
-                );
-            else if (native === "BigInt")
-                conditions.push(
-                    ts.factory.createCallExpression(
-                        importer.use("is_bigint_string"),
-                        undefined,
-                        [input],
-                    ),
-                );
-            else if (native === "Number")
-                conditions.push(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createFalse(),
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("Number.isNaN"),
-                            undefined,
-                            [
-                                ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("Number"),
-                                    undefined,
-                                    [input],
-                                ),
-                            ],
-                        ),
-                    ),
-                );
-
-        return conditions.length === 0
-            ? ts.factory.createTrue()
-            : conditions.length === 1
-            ? conditions[0]!
-            : conditions.reduce(ts.factory.createLogicalOr);
-    };
-
-const atomist = (entry: ICheckEntry) => {
-    return [
-        ...(entry.expression ? [entry.expression] : []),
-        ...(entry.conditions.length === 0
-            ? []
-            : [
-                  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)),
-              ]),
-    ].reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-};
+import ts from "typescript";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { IProject } from "../../transformers/IProject";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_bigint } from "./check_bigint";
+import { check_number } from "./check_number";
+import { check_string } from "./check_string";
+import { check_template } from "./check_template";
+
+export const check_dynamic_key =
+    (project: IProject) =>
+    (importer: FunctionImporter) =>
+    (input: ts.Expression, metadata: Metadata): ts.Expression => {
+        // IF PURE STRING EXISTS, THEN SKIP VALIDATION
+        if (
+            (metadata.atomics.length !== 0 &&
+                metadata.atomics.some(
+                    (a) =>
+                        a.type === "string" &&
+                        a.tags.filter((row) =>
+                            row.every((t) => t.validate !== undefined),
+                        ).length === 0,
+                )) ||
+            (metadata.natives.length !== 0 &&
+                metadata.natives.some((type) => type === "String"))
+        )
+            return ts.factory.createTrue();
+
+        const conditions: ts.Expression[] = [];
+
+        // NULLISH COALESCING
+        if (metadata.nullable === true)
+            conditions.push(
+                ts.factory.createStrictEquality(
+                    ts.factory.createStringLiteral("null"),
+                    input,
+                ),
+            );
+        if (metadata.isRequired() === false)
+            conditions.push(
+                ts.factory.createStrictEquality(
+                    ts.factory.createStringLiteral("undefined"),
+                    input,
+                ),
+            );
+
+        // ATOMICS
+        for (const atom of metadata.atomics)
+            if (atom.type === "boolean")
+                conditions.push(
+                    ts.factory.createLogicalOr(
+                        ts.factory.createStrictEquality(
+                            ts.factory.createStringLiteral("false"),
+                            input,
+                        ),
+                        ts.factory.createStrictEquality(
+                            ts.factory.createStringLiteral("true"),
+                            input,
+                        ),
+                    ),
+                );
+            else if (atom.type === "bigint")
+                conditions.push(
+                    ts.factory.createLogicalAnd(
+                        ts.factory.createCallExpression(
+                            importer.use("is_bigint_string"),
+                            undefined,
+                            [input],
+                        ),
+                        atomist(
+                            check_bigint(project)(atom)(
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("BigInt"),
+                                    undefined,
+                                    [input],
+                                ),
+                            ),
+                        ),
+                    ),
+                );
+            else if (atom.type === "number")
+                conditions.push(
+                    atomist(
+                        check_number(project, true)(atom)(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("Number"),
+                                undefined,
+                                [input],
+                            ),
+                        ),
+                    ),
+                );
+            else conditions.push(atomist(check_string(project)(atom)(input)));
+
+        // CONSTANTS
+        for (const constant of metadata.constants)
+            for (const value of constant.values)
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createStringLiteral(String(value)),
+                        input,
+                    ),
+                );
+
+        // TEMPLATES
+        if (!!metadata.templates.length)
+            conditions.push(atomist(check_template(metadata.templates)(input)));
+
+        // NATIVES
+        for (const native of metadata.natives)
+            if (native === "Boolean")
+                conditions.push(
+                    ts.factory.createLogicalOr(
+                        ts.factory.createStrictEquality(
+                            ts.factory.createStringLiteral("false"),
+                            input,
+                        ),
+                        ts.factory.createStrictEquality(
+                            ts.factory.createStringLiteral("true"),
+                            input,
+                        ),
+                    ),
+                );
+            else if (native === "BigInt")
+                conditions.push(
+                    ts.factory.createCallExpression(
+                        importer.use("is_bigint_string"),
+                        undefined,
+                        [input],
+                    ),
+                );
+            else if (native === "Number")
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createFalse(),
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("Number.isNaN"),
+                            undefined,
+                            [
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("Number"),
+                                    undefined,
+                                    [input],
+                                ),
+                            ],
+                        ),
+                    ),
+                );
+
+        return conditions.length === 0
+            ? ts.factory.createTrue()
+            : conditions.length === 1
+            ? conditions[0]!
+            : conditions.reduce(ts.factory.createLogicalOr);
+    };
+
+const atomist = (entry: ICheckEntry) => {
+    return [
+        ...(entry.expression ? [entry.expression] : []),
+        ...(entry.conditions.length === 0
+            ? []
+            : [
+                  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)),
+              ]),
+    ].reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+};