typia 3.6.2 → 3.6.3

package/src/programmers/internal/check_native.ts

@@ -1,21 +1,21 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-/**
- * @internal
- */
-export const check_native = (type: string) => (input: ts.Expression) => {
-    const instanceOf = ExpressionFactory.isInstanceOf(input, type);
-    return ATOMIC_LIKE.has(type)
-        ? ts.factory.createLogicalOr(
-              ts.factory.createStrictEquality(
-                  ts.factory.createStringLiteral(type.toLowerCase()),
-                  ts.factory.createTypeOfExpression(input),
-              ),
-              instanceOf,
-          )
-        : instanceOf;
-};
-
-const ATOMIC_LIKE = new Set(["Boolean", "Number", "String"]);
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+/**
+ * @internal
+ */
+export const check_native = (type: string) => (input: ts.Expression) => {
+    const instanceOf = ExpressionFactory.isInstanceOf(input, type);
+    return ATOMIC_LIKE.has(type)
+        ? ts.factory.createLogicalOr(
+              ts.factory.createStrictEquality(
+                  ts.factory.createStringLiteral(type.toLowerCase()),
+                  ts.factory.createTypeOfExpression(input),
+              ),
+              instanceOf,
+          )
+        : instanceOf;
+};
+
+const ATOMIC_LIKE = new Set(["Boolean", "Number", "String"]);

package/src/programmers/internal/check_number.ts

@@ -1,145 +1,145 @@
-import ts from "typescript";
-
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-import { IProject } from "../../transformers/IProject";
-
-import { OptionPredicator } from "../helpers/OptionPredicator";
-
-/**
- * @internal
- */
-export const check_number =
-    ({ options }: IProject, numeric: boolean) =>
-    (input: ts.Expression, tagList: IMetadataTag[]) => {
-        // TYPEOF STATEMENT
-        const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("number"),
-                ts.factory.createTypeOfExpression(input),
-            ),
-        ];
-
-        // CHECK FINITE AND NAN
-        const finite: boolean =
-            (!!tagList.find(
-                (tag) =>
-                    tag.kind === "minimum" || tag.kind === "exclusiveMinimum",
-            ) &&
-                !!tagList.find(
-                    (tag) =>
-                        tag.kind === "maximum" ||
-                        tag.kind === "exclusiveMaximum",
-                )) ||
-            !!tagList.find(
-                (tag) => tag.kind === "step" || tag.kind === "multipleOf",
-            );
-
-        if (numeric === true && finite === false)
-            if (OptionPredicator.finite(options))
-                conditions.push(
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier("Number.isFinite"),
-                        undefined,
-                        [input],
-                    ),
-                );
-            else if (OptionPredicator.numeric(options))
-                conditions.push(
-                    ts.factory.createLogicalNot(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("Number.isNaN"),
-                            undefined,
-                            [input],
-                        ),
-                    ),
-                );
-
-        // TAG (RANGE)
-        for (const tag of tagList)
-            if (tag.kind === "type") {
-                conditions.push(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("parseInt"),
-                            undefined,
-                            [input],
-                        ),
-                        input,
-                    ),
-                );
-                if (tag.value === "uint")
-                    conditions.push(
-                        ts.factory.createLessThanEquals(
-                            ts.factory.createNumericLiteral(0),
-                            input,
-                        ),
-                    );
-            } else if (tag.kind === "multipleOf")
-                conditions.push(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createNumericLiteral(0),
-                        ts.factory.createModulo(
-                            input,
-                            ts.factory.createNumericLiteral(tag.value),
-                        ),
-                    ),
-                );
-            else if (tag.kind === "step") {
-                const modulo = () =>
-                    ts.factory.createModulo(
-                        input,
-                        ts.factory.createNumericLiteral(tag.value),
-                    );
-                const minimum = (() => {
-                    for (const tag of tagList)
-                        if (tag.kind === "minimum") return tag.value;
-                        else if (tag.kind === "exclusiveMinimum")
-                            return tag.value;
-                    return undefined;
-                })();
-                conditions.push(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createNumericLiteral(0),
-                        minimum !== undefined
-                            ? ts.factory.createSubtract(
-                                  modulo(),
-                                  ts.factory.createNumericLiteral(minimum),
-                              )
-                            : modulo(),
-                    ),
-                );
-            } else if (tag.kind === "minimum")
-                conditions.push(
-                    ts.factory.createLessThanEquals(
-                        ts.factory.createNumericLiteral(tag.value),
-                        input,
-                    ),
-                );
-            else if (tag.kind === "maximum")
-                conditions.push(
-                    ts.factory.createGreaterThanEquals(
-                        ts.factory.createNumericLiteral(tag.value),
-                        input,
-                    ),
-                );
-            else if (tag.kind === "exclusiveMinimum")
-                conditions.push(
-                    ts.factory.createLessThan(
-                        ts.factory.createNumericLiteral(tag.value),
-                        input,
-                    ),
-                );
-            else if (tag.kind === "exclusiveMaximum")
-                conditions.push(
-                    ts.factory.createGreaterThan(
-                        ts.factory.createNumericLiteral(tag.value),
-                        input,
-                    ),
-                );
-
-        // COMBINATION
-        return conditions.length === 1
-            ? conditions[0]!
-            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-    };
+import ts from "typescript";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { IProject } from "../../transformers/IProject";
+
+import { OptionPredicator } from "../helpers/OptionPredicator";
+
+/**
+ * @internal
+ */
+export const check_number =
+    ({ options }: IProject, numeric: boolean) =>
+    (input: ts.Expression, tagList: IMetadataTag[]) => {
+        // TYPEOF STATEMENT
+        const conditions: ts.Expression[] = [
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("number"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+        ];
+
+        // CHECK FINITE AND NAN
+        const finite: boolean =
+            (!!tagList.find(
+                (tag) =>
+                    tag.kind === "minimum" || tag.kind === "exclusiveMinimum",
+            ) &&
+                !!tagList.find(
+                    (tag) =>
+                        tag.kind === "maximum" ||
+                        tag.kind === "exclusiveMaximum",
+                )) ||
+            !!tagList.find(
+                (tag) => tag.kind === "step" || tag.kind === "multipleOf",
+            );
+
+        if (numeric === true && finite === false)
+            if (OptionPredicator.finite(options))
+                conditions.push(
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier("Number.isFinite"),
+                        undefined,
+                        [input],
+                    ),
+                );
+            else if (OptionPredicator.numeric(options))
+                conditions.push(
+                    ts.factory.createLogicalNot(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("Number.isNaN"),
+                            undefined,
+                            [input],
+                        ),
+                    ),
+                );
+
+        // TAG (RANGE)
+        for (const tag of tagList)
+            if (tag.kind === "type") {
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("parseInt"),
+                            undefined,
+                            [input],
+                        ),
+                        input,
+                    ),
+                );
+                if (tag.value === "uint")
+                    conditions.push(
+                        ts.factory.createLessThanEquals(
+                            ts.factory.createNumericLiteral(0),
+                            input,
+                        ),
+                    );
+            } else if (tag.kind === "multipleOf")
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createNumericLiteral(0),
+                        ts.factory.createModulo(
+                            input,
+                            ts.factory.createNumericLiteral(tag.value),
+                        ),
+                    ),
+                );
+            else if (tag.kind === "step") {
+                const modulo = () =>
+                    ts.factory.createModulo(
+                        input,
+                        ts.factory.createNumericLiteral(tag.value),
+                    );
+                const minimum = (() => {
+                    for (const tag of tagList)
+                        if (tag.kind === "minimum") return tag.value;
+                        else if (tag.kind === "exclusiveMinimum")
+                            return tag.value;
+                    return undefined;
+                })();
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createNumericLiteral(0),
+                        minimum !== undefined
+                            ? ts.factory.createSubtract(
+                                  modulo(),
+                                  ts.factory.createNumericLiteral(minimum),
+                              )
+                            : modulo(),
+                    ),
+                );
+            } else if (tag.kind === "minimum")
+                conditions.push(
+                    ts.factory.createLessThanEquals(
+                        ts.factory.createNumericLiteral(tag.value),
+                        input,
+                    ),
+                );
+            else if (tag.kind === "maximum")
+                conditions.push(
+                    ts.factory.createGreaterThanEquals(
+                        ts.factory.createNumericLiteral(tag.value),
+                        input,
+                    ),
+                );
+            else if (tag.kind === "exclusiveMinimum")
+                conditions.push(
+                    ts.factory.createLessThan(
+                        ts.factory.createNumericLiteral(tag.value),
+                        input,
+                    ),
+                );
+            else if (tag.kind === "exclusiveMaximum")
+                conditions.push(
+                    ts.factory.createGreaterThan(
+                        ts.factory.createNumericLiteral(tag.value),
+                        input,
+                    ),
+                );
+
+        // COMBINATION
+        return conditions.length === 1
+            ? conditions[0]!
+            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+    };

package/src/programmers/internal/check_object.ts

@@ -1,48 +1,48 @@
-import ts from "typescript";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { IExpressionEntry } from "../helpers/IExpressionEntry";
-import { check_dynamic_properties } from "./check_dynamic_properties";
-import { check_everything } from "./check_everything";
-
-/**
- * @internal
- */
-export const check_object =
-    (props: check_object.IProps) =>
-    (importer: FunctionImporter) =>
-    (input: ts.Expression, entries: IExpressionEntry<ts.Expression>[]) => {
-        // PREPARE ASSETS
-        const regular = entries.filter((entry) => entry.key.isSoleLiteral());
-        const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
-        const flags: ts.Expression[] = regular.map((entry) => entry.expression);
-
-        // REGULAR WITHOUT DYNAMIC PROPERTIES
-        if (props.equals === false && dynamic.length === 0)
-            return regular.length === 0 ? props.positive : reduce(props)(flags);
-
-        // CHECK DYNAMIC PROPERTIES
-        flags.push(
-            check_dynamic_properties(props)(importer)(input, regular, dynamic),
-        );
-        return reduce(props)(flags);
-    };
-export namespace check_object {
-    export interface IProps {
-        equals: boolean;
-        assert: boolean;
-        undefined: boolean;
-        halt?: (exp: ts.Expression) => ts.Expression;
-        reduce: (a: ts.Expression, b: ts.Expression) => ts.Expression;
-        positive: ts.Expression;
-        superfluous: (value: ts.Expression) => ts.Expression;
-        entries?: ts.Identifier;
-    }
-}
-
-const reduce = (props: check_object.IProps) => (expressions: ts.Expression[]) =>
-    props.assert
-        ? expressions.reduce(props.reduce)
-        : check_everything(
-              ts.factory.createArrayLiteralExpression(expressions),
-          );
+import ts from "typescript";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+import { check_dynamic_properties } from "./check_dynamic_properties";
+import { check_everything } from "./check_everything";
+
+/**
+ * @internal
+ */
+export const check_object =
+    (props: check_object.IProps) =>
+    (importer: FunctionImporter) =>
+    (input: ts.Expression, entries: IExpressionEntry<ts.Expression>[]) => {
+        // PREPARE ASSETS
+        const regular = entries.filter((entry) => entry.key.isSoleLiteral());
+        const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
+        const flags: ts.Expression[] = regular.map((entry) => entry.expression);
+
+        // REGULAR WITHOUT DYNAMIC PROPERTIES
+        if (props.equals === false && dynamic.length === 0)
+            return regular.length === 0 ? props.positive : reduce(props)(flags);
+
+        // CHECK DYNAMIC PROPERTIES
+        flags.push(
+            check_dynamic_properties(props)(importer)(input, regular, dynamic),
+        );
+        return reduce(props)(flags);
+    };
+export namespace check_object {
+    export interface IProps {
+        equals: boolean;
+        assert: boolean;
+        undefined: boolean;
+        halt?: (exp: ts.Expression) => ts.Expression;
+        reduce: (a: ts.Expression, b: ts.Expression) => ts.Expression;
+        positive: ts.Expression;
+        superfluous: (value: ts.Expression) => ts.Expression;
+        entries?: ts.Identifier;
+    }
+}
+
+const reduce = (props: check_object.IProps) => (expressions: ts.Expression[]) =>
+    props.assert
+        ? expressions.reduce(props.reduce)
+        : check_everything(
+              ts.factory.createArrayLiteralExpression(expressions),
+          );

package/src/programmers/internal/check_string.ts

@@ -1,24 +1,24 @@
-import ts from "typescript";
-
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { check_string_tags } from "./check_string_tags";
-
-/**
- * @internal
- */
-export function check_string(importer: FunctionImporter) {
-    return function (input: ts.Expression, tagList: IMetadataTag[]) {
-        const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("string"),
-                ts.factory.createTypeOfExpression(input),
-            ),
-            ...check_string_tags(importer)(input, tagList),
-        ];
-        return conditions.length === 1
-            ? conditions[0]!
-            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-    };
-}
+import ts from "typescript";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { check_string_tags } from "./check_string_tags";
+
+/**
+ * @internal
+ */
+export function check_string(importer: FunctionImporter) {
+    return function (input: ts.Expression, tagList: IMetadataTag[]) {
+        const conditions: ts.Expression[] = [
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("string"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+            ...check_string_tags(importer)(input, tagList),
+        ];
+        return conditions.length === 1
+            ? conditions[0]!
+            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+    };
+}

package/src/programmers/internal/check_string_tags.ts

@@ -1,63 +1,63 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-
-/**
- * @internal
- */
-export const check_string_tags =
-    (importer: FunctionImporter) =>
-    (input: ts.Expression, tagList: IMetadataTag[]) => {
-        const conditions: ts.Expression[] = [];
-        for (const tag of tagList)
-            if (tag.kind === "format")
-                conditions.push(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createTrue(),
-                        ts.factory.createCallExpression(
-                            importer.use(`is_${tag.value}`),
-                            undefined,
-                            [input],
-                        ),
-                    ),
-                );
-            else if (tag.kind === "pattern")
-                conditions.push(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createTrue(),
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier(
-                                `RegExp(/${tag.value}/).test`,
-                            ),
-                            undefined,
-                            [input],
-                        ),
-                    ),
-                );
-            else if (tag.kind === "length")
-                conditions.push(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createNumericLiteral(tag.value),
-                        IdentifierFactory.join(input, "length"),
-                    ),
-                );
-            else if (tag.kind === "minLength")
-                conditions.push(
-                    ts.factory.createLessThanEquals(
-                        ts.factory.createNumericLiteral(tag.value),
-                        IdentifierFactory.join(input, "length"),
-                    ),
-                );
-            else if (tag.kind === "maxLength")
-                conditions.push(
-                    ts.factory.createGreaterThanEquals(
-                        ts.factory.createNumericLiteral(tag.value),
-                        IdentifierFactory.join(input, "length"),
-                    ),
-                );
-        return conditions;
-    };
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+
+/**
+ * @internal
+ */
+export const check_string_tags =
+    (importer: FunctionImporter) =>
+    (input: ts.Expression, tagList: IMetadataTag[]) => {
+        const conditions: ts.Expression[] = [];
+        for (const tag of tagList)
+            if (tag.kind === "format")
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createTrue(),
+                        ts.factory.createCallExpression(
+                            importer.use(`is_${tag.value}`),
+                            undefined,
+                            [input],
+                        ),
+                    ),
+                );
+            else if (tag.kind === "pattern")
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createTrue(),
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier(
+                                `RegExp(/${tag.value}/).test`,
+                            ),
+                            undefined,
+                            [input],
+                        ),
+                    ),
+                );
+            else if (tag.kind === "length")
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createNumericLiteral(tag.value),
+                        IdentifierFactory.join(input, "length"),
+                    ),
+                );
+            else if (tag.kind === "minLength")
+                conditions.push(
+                    ts.factory.createLessThanEquals(
+                        ts.factory.createNumericLiteral(tag.value),
+                        IdentifierFactory.join(input, "length"),
+                    ),
+                );
+            else if (tag.kind === "maxLength")
+                conditions.push(
+                    ts.factory.createGreaterThanEquals(
+                        ts.factory.createNumericLiteral(tag.value),
+                        IdentifierFactory.join(input, "length"),
+                    ),
+                );
+        return conditions;
+    };