typia 5.0.0-dev.20230715 → 5.0.0-dev.20230726

package/src/programmers/internal/check_string.ts

@@ -1,25 +1,25 @@
-import ts from "typescript";
-
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { check_custom } from "./check_custom";
-import { check_string_tags } from "./check_string_tags";
-
-/**
- * @internal
- */
-export const check_string =
-    (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTags: ts.JSDocTagInfo[]) =>
-    (input: ts.Expression) => ({
-        expression: ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral("string"),
-            ts.factory.createTypeOfExpression(input),
-        ),
-        tags: [
-            ...check_string_tags(importer)(metaTags)(input),
-            ...check_custom("string")(importer)(jsDocTags)(input),
-        ],
-    });
+import ts from "typescript";
+
+import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { check_custom } from "./check_custom";
+import { check_string_tags } from "./check_string_tags";
+
+/**
+ * @internal
+ */
+export const check_string =
+    (importer: FunctionImporter) =>
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTags: ts.JSDocTagInfo[]) =>
+    (input: ts.Expression) => ({
+        expression: ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("string"),
+            ts.factory.createTypeOfExpression(input),
+        ),
+        tags: [
+            ...check_string_tags(importer)(metaTags)(input),
+            ...check_custom("string")(importer)(jsDocTags)(input),
+        ],
+    });

package/src/programmers/internal/check_string_tags.ts

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

package/src/programmers/internal/check_template.ts

@@ -1,56 +1,56 @@
-import ts from "typescript";
-
-import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-import { Metadata } from "../../metadata/Metadata";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { check_custom } from "./check_custom";
-import { check_string_tags } from "./check_string_tags";
-import { template_to_pattern } from "./template_to_pattern";
-
-/**
- * @internal
- */
-export const check_template =
-    (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTags: IJsDocTagInfo[]) =>
-    (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),
-            ),
-            tags: [
-                ...check_string_tags(importer)(metaTags)(input),
-                ...check_custom("string")(importer)(jsDocTags)(input),
-            ],
-        };
-    };
+import ts from "typescript";
+
+import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
+import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_custom } from "./check_custom";
+import { check_string_tags } from "./check_string_tags";
+import { template_to_pattern } from "./template_to_pattern";
+
+/**
+ * @internal
+ */
+export const check_template =
+    (importer: FunctionImporter) =>
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTags: IJsDocTagInfo[]) =>
+    (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),
+            ),
+            tags: [
+                ...check_string_tags(importer)(metaTags)(input),
+                ...check_custom("string")(importer)(jsDocTags)(input),
+            ],
+        };
+    };