typia 5.0.4 → 5.0.5-dev.20230921

package/src/programmers/internal/check_number.ts

@@ -1,105 +1,105 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { IProject } from "../../transformers/IProject";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { OptionPredicator } from "../helpers/OptionPredicator";
-
-/**
- * @internal
- */
-export const check_number =
-    (project: IProject, numeric: boolean) =>
-    (atomic: MetadataAtomic) =>
-    (input: ts.Expression): ICheckEntry => {
-        const base = ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral("number"),
-            ts.factory.createTypeOfExpression(input),
-        );
-        const addition: ts.Expression | null =
-            numeric === true
-                ? OptionPredicator.finite(project.options)
-                    ? ts.factory.createCallExpression(
-                          ts.factory.createIdentifier("Number.isFinite"),
-                          undefined,
-                          [input],
-                      )
-                    : OptionPredicator.numeric(project.options)
-                    ? ts.factory.createLogicalNot(
-                          ts.factory.createCallExpression(
-                              ts.factory.createIdentifier("Number.isNaN"),
-                              undefined,
-                              [input],
-                          ),
-                      )
-                    : null
-                : null;
-
-        const conditions: ICheckEntry.ICondition[][] =
-            check_numeric_type_tags(project)(atomic)(addition)(input);
-
-        return {
-            expected: atomic.getName(),
-            expression:
-                addition !== null && conditions.length === 0
-                    ? ts.factory.createLogicalAnd(base, addition)
-                    : base,
-            conditions,
-        };
-    };
-
-/**
- * @internal
- */
-const check_numeric_type_tags =
-    (project: IProject) =>
-    (atomic: MetadataAtomic) =>
-    (addition: ts.Expression | null) =>
-    (input: ts.Expression): ICheckEntry.ICondition[][] =>
-        atomic.tags.map((row) => [
-            ...(addition === null
-                ? []
-                : row.some(
-                      (tag) =>
-                          tag.kind === "type" &&
-                          (tag.value === "int32" ||
-                              tag.value === "uint32" ||
-                              tag.value === "int64" ||
-                              tag.value === "uint64" ||
-                              tag.value === "float"),
-                  ) ||
-                  row.some(
-                      (tag) =>
-                          tag.kind === "multipleOf" &&
-                          typeof tag.value === "number",
-                  ) ||
-                  (row.some(
-                      (tag) =>
-                          (tag.kind === "minimum" ||
-                              tag.kind === "exclusiveMinimum") &&
-                          typeof tag.value === "number",
-                  ) &&
-                      row.some(
-                          (tag) =>
-                              (tag.kind === "maximum" ||
-                                  tag.kind === "exclusiveMaximum") &&
-                              typeof tag.value === "number",
-                      ))
-                ? []
-                : [
-                      {
-                          expected: "number",
-                          expression: addition!,
-                      },
-                  ]),
-            ...row.map((tag) => ({
-                expected: `number & ${tag.name}`,
-                expression: ExpressionFactory.transpile(project.context)(
-                    tag.validate,
-                )(input),
-            })),
-        ]);
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { OptionPredicator } from "../helpers/OptionPredicator";
+
+/**
+ * @internal
+ */
+export const check_number =
+    (project: IProject, numeric: boolean) =>
+    (atomic: MetadataAtomic) =>
+    (input: ts.Expression): ICheckEntry => {
+        const base = ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("number"),
+            ts.factory.createTypeOfExpression(input),
+        );
+        const addition: ts.Expression | null =
+            numeric === true
+                ? OptionPredicator.finite(project.options)
+                    ? ts.factory.createCallExpression(
+                          ts.factory.createIdentifier("Number.isFinite"),
+                          undefined,
+                          [input],
+                      )
+                    : OptionPredicator.numeric(project.options)
+                    ? ts.factory.createLogicalNot(
+                          ts.factory.createCallExpression(
+                              ts.factory.createIdentifier("Number.isNaN"),
+                              undefined,
+                              [input],
+                          ),
+                      )
+                    : null
+                : null;
+
+        const conditions: ICheckEntry.ICondition[][] =
+            check_numeric_type_tags(project)(atomic)(addition)(input);
+
+        return {
+            expected: atomic.getName(),
+            expression:
+                addition !== null && conditions.length === 0
+                    ? ts.factory.createLogicalAnd(base, addition)
+                    : base,
+            conditions,
+        };
+    };
+
+/**
+ * @internal
+ */
+const check_numeric_type_tags =
+    (project: IProject) =>
+    (atomic: MetadataAtomic) =>
+    (addition: ts.Expression | null) =>
+    (input: ts.Expression): ICheckEntry.ICondition[][] =>
+        atomic.tags.map((row) => [
+            ...(addition === null
+                ? []
+                : row.some(
+                      (tag) =>
+                          tag.kind === "type" &&
+                          (tag.value === "int32" ||
+                              tag.value === "uint32" ||
+                              tag.value === "int64" ||
+                              tag.value === "uint64" ||
+                              tag.value === "float"),
+                  ) ||
+                  row.some(
+                      (tag) =>
+                          tag.kind === "multipleOf" &&
+                          typeof tag.value === "number",
+                  ) ||
+                  (row.some(
+                      (tag) =>
+                          (tag.kind === "minimum" ||
+                              tag.kind === "exclusiveMinimum") &&
+                          typeof tag.value === "number",
+                  ) &&
+                      row.some(
+                          (tag) =>
+                              (tag.kind === "maximum" ||
+                                  tag.kind === "exclusiveMaximum") &&
+                              typeof tag.value === "number",
+                      ))
+                ? []
+                : [
+                      {
+                          expected: "number",
+                          expression: addition!,
+                      },
+                  ]),
+            ...row.map((tag) => ({
+                expected: `number & ${tag.name}`,
+                expression: ExpressionFactory.transpile(project.context)(
+                    tag.validate,
+                )(input),
+            })),
+        ]);

package/src/programmers/internal/check_object.ts

@@ -1,55 +1,55 @@
-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);
-    };
-
-/**
- * @internal
- */
-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;
-    }
-}
-
-/**
- * @internal
- */
-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);
+    };
+
+/**
+ * @internal
+ */
+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;
+    }
+}
+
+/**
+ * @internal
+ */
+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,45 +1,45 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-
-import { IProject } from "../../transformers/IProject";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-
-/**
- * @internal
- */
-export const check_string =
-    (project: IProject) =>
-    (atomic: MetadataAtomic) =>
-    (input: ts.Expression): ICheckEntry => {
-        const conditions: ICheckEntry.ICondition[][] =
-            check_string_type_tags(project)(atomic)(input);
-
-        return {
-            expected: atomic.getName(),
-            expression: ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("string"),
-                ts.factory.createTypeOfExpression(input),
-            ),
-            conditions,
-        };
-    };
-
-/**
- * @internal
- */
-const check_string_type_tags =
-    (project: IProject) =>
-    (atomic: MetadataAtomic) =>
-    (input: ts.Expression): ICheckEntry.ICondition[][] =>
-        atomic.tags.map((row) =>
-            row.map((tag) => ({
-                expected: `string & ${tag.name}`,
-                expression: ExpressionFactory.transpile(project.context)(
-                    tag.validate,
-                )(input),
-            })),
-        );
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+
+/**
+ * @internal
+ */
+export const check_string =
+    (project: IProject) =>
+    (atomic: MetadataAtomic) =>
+    (input: ts.Expression): ICheckEntry => {
+        const conditions: ICheckEntry.ICondition[][] =
+            check_string_type_tags(project)(atomic)(input);
+
+        return {
+            expected: atomic.getName(),
+            expression: ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("string"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+            conditions,
+        };
+    };
+
+/**
+ * @internal
+ */
+const check_string_type_tags =
+    (project: IProject) =>
+    (atomic: MetadataAtomic) =>
+    (input: ts.Expression): ICheckEntry.ICondition[][] =>
+        atomic.tags.map((row) =>
+            row.map((tag) => ({
+                expected: `string & ${tag.name}`,
+                expression: ExpressionFactory.transpile(project.context)(
+                    tag.validate,
+                )(input),
+            })),
+        );

package/src/programmers/internal/check_template.ts

@@ -1,61 +1,61 @@
-import ts from "typescript";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { template_to_pattern } from "./template_to_pattern";
-
-/**
- * @internal
- */
-export const check_template =
-    (templates: Metadata[][]) =>
-    (input: ts.Expression): ICheckEntry => {
-        // TYPEOF STRING & TAGS
-        const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("string"),
-                ts.factory.createTypeOfExpression(input),
-            ),
-        ];
-
-        // TEMPLATES
-        const internal: ts.Expression[] = templates.map((tpl) =>
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier(
-                    `RegExp(/${template_to_pattern(true)(tpl)}/).test`,
-                ),
-                undefined,
-                [input],
-            ),
-        );
-        conditions.push(
-            internal.length === 1
-                ? internal[0]!
-                : internal.reduce((x, y) => ts.factory.createLogicalOr(x, y)),
-        );
-
-        // COMBINATION
-        return {
-            expression: conditions.reduce((x, y) =>
-                ts.factory.createLogicalAnd(x, y),
-            ),
-            conditions: [],
-            expected: templates
-                .map(
-                    (tpl) =>
-                        "`" +
-                        tpl
-                            .map((child) =>
-                                child.isConstant() && child.size() === 1
-                                    ? child.constants[0]!.values[0]!
-                                    : `$\{${child.getName()}\}`,
-                            )
-                            .join("")
-                            .split("`")
-                            .join("\\`") +
-                        "`",
-                )
-                .join(" | "),
-        };
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { template_to_pattern } from "./template_to_pattern";
+
+/**
+ * @internal
+ */
+export const check_template =
+    (templates: Metadata[][]) =>
+    (input: ts.Expression): ICheckEntry => {
+        // TYPEOF STRING & TAGS
+        const conditions: ts.Expression[] = [
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("string"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+        ];
+
+        // TEMPLATES
+        const internal: ts.Expression[] = templates.map((tpl) =>
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier(
+                    `RegExp(/${template_to_pattern(true)(tpl)}/).test`,
+                ),
+                undefined,
+                [input],
+            ),
+        );
+        conditions.push(
+            internal.length === 1
+                ? internal[0]!
+                : internal.reduce((x, y) => ts.factory.createLogicalOr(x, y)),
+        );
+
+        // COMBINATION
+        return {
+            expression: conditions.reduce((x, y) =>
+                ts.factory.createLogicalAnd(x, y),
+            ),
+            conditions: [],
+            expected: templates
+                .map(
+                    (tpl) =>
+                        "`" +
+                        tpl
+                            .map((child) =>
+                                child.isConstant() && child.size() === 1
+                                    ? child.constants[0]!.values[0]!
+                                    : `$\{${child.getName()}\}`,
+                            )
+                            .join("")
+                            .split("`")
+                            .join("\\`") +
+                        "`",
+                )
+                .join(" | "),
+        };
+    };