typia 3.6.10 → 3.7.0-dev.20230331

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;
+    };

package/src/programmers/internal/check_template.ts

@@ -1,50 +1,50 @@
-import ts from "typescript";
-
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-import { Metadata } from "../../metadata/Metadata";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { check_string_tags } from "./check_string_tags";
-import { template_to_pattern } from "./template_to_pattern";
-
-/**
- * @internal
- */
-export const check_template =
-    (importer: FunctionImporter) =>
-    (
-        input: ts.Expression,
-        templates: Metadata[][],
-        tagList: IMetadataTag[],
-    ) => {
-        // TYPEOF STRING & TAGS
-        const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("string"),
-                ts.factory.createTypeOfExpression(input),
-            ),
-            ...check_string_tags(importer)(input, tagList),
-        ];
-
-        // TEMPLATES
-        const internal = templates.map((tpl) =>
-            ts.factory.createStrictEquality(
-                ts.factory.createTrue(),
-                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 conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-    };
+import ts from "typescript";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+import { Metadata } from "../../metadata/Metadata";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { check_string_tags } from "./check_string_tags";
+import { template_to_pattern } from "./template_to_pattern";
+
+/**
+ * @internal
+ */
+export const check_template =
+    (importer: FunctionImporter) =>
+    (
+        input: ts.Expression,
+        templates: Metadata[][],
+        tagList: IMetadataTag[],
+    ) => {
+        // TYPEOF STRING & TAGS
+        const conditions: ts.Expression[] = [
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("string"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+            ...check_string_tags(importer)(input, tagList),
+        ];
+
+        // TEMPLATES
+        const internal = templates.map((tpl) =>
+            ts.factory.createStrictEquality(
+                ts.factory.createTrue(),
+                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 conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+    };