typia 3.7.2 → 3.7.3

package/src/programmers/internal/get_comment_tags.ts

@@ -1,23 +1,23 @@
-import { MetadataTagFactory } from "../../factories/MetadataTagFactory";
-
-import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
-
-/**
- * @internal
- */
-export const get_comment_tags =
-    (excludeMetaTags: boolean) => (jsDocTags: IJsDocTagInfo[]) =>
-        jsDocTags
-            .filter(
-                (tag) =>
-                    tag.name !== "random" &&
-                    (!tag.text?.length ||
-                        (tag.text?.length === 1 &&
-                            tag.text?.[0]?.kind === "text")) &&
-                    (!excludeMetaTags ||
-                        MetadataTagFactory._PARSER[tag.name] === undefined),
-            )
-            .map((tag) => ({
-                name: tag.name,
-                value: tag.text?.[0]?.text,
-            }));
+import { MetadataTagFactory } from "../../factories/MetadataTagFactory";
+
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
+
+/**
+ * @internal
+ */
+export const get_comment_tags =
+    (excludeMetaTags: boolean) => (jsDocTags: IJsDocTagInfo[]) =>
+        jsDocTags
+            .filter(
+                (tag) =>
+                    tag.name !== "random" &&
+                    (!tag.text?.length ||
+                        (tag.text?.length === 1 &&
+                            tag.text?.[0]?.kind === "text")) &&
+                    (!excludeMetaTags ||
+                        MetadataTagFactory._PARSER[tag.name] === undefined),
+            )
+            .map((tag) => ({
+                name: tag.name,
+                value: tag.text?.[0]?.text,
+            }));

package/src/programmers/internal/metadata_to_pattern.ts

@@ -1,34 +1,34 @@
-import { Metadata } from "../../metadata/Metadata";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-import { PatternUtil } from "../../utils/PatternUtil";
-
-import { template_to_pattern } from "./template_to_pattern";
-
-/**
- * @internal
- */
-export const metadata_to_pattern =
-    (top: boolean) =>
-    (meta: Metadata): string => {
-        if (meta.atomics.find((type) => type === "string") !== undefined)
-            return "(.*)";
-
-        const values: string[] = ArrayUtil.flat(
-            meta.constants.map((c) => {
-                if (c.type !== "string")
-                    return c.values.map((v) => v.toString());
-                return c.values.map((str) => PatternUtil.escape(str));
-            }),
-        );
-        for (const type of meta.atomics)
-            if (type === "number" || type === "bigint")
-                values.push(PatternUtil.NUMBER);
-            else if (type === "boolean") values.push(PatternUtil.BOOLEAN);
-        for (const childTpl of meta.templates)
-            values.push("(" + template_to_pattern(false)(childTpl) + ")");
-
-        const pattern: string =
-            values.length === 1 ? values[0]! : "(" + values.join("|") + ")";
-        return top ? PatternUtil.fix(pattern) : pattern;
-    };
+import { Metadata } from "../../metadata/Metadata";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+import { PatternUtil } from "../../utils/PatternUtil";
+
+import { template_to_pattern } from "./template_to_pattern";
+
+/**
+ * @internal
+ */
+export const metadata_to_pattern =
+    (top: boolean) =>
+    (meta: Metadata): string => {
+        if (meta.atomics.find((type) => type === "string") !== undefined)
+            return "(.*)";
+
+        const values: string[] = ArrayUtil.flat(
+            meta.constants.map((c) => {
+                if (c.type !== "string")
+                    return c.values.map((v) => v.toString());
+                return c.values.map((str) => PatternUtil.escape(str));
+            }),
+        );
+        for (const type of meta.atomics)
+            if (type === "number" || type === "bigint")
+                values.push(PatternUtil.NUMBER);
+            else if (type === "boolean") values.push(PatternUtil.BOOLEAN);
+        for (const childTpl of meta.templates)
+            values.push("(" + template_to_pattern(false)(childTpl) + ")");
+
+        const pattern: string =
+            values.length === 1 ? values[0]! : "(" + values.join("|") + ")";
+        return top ? PatternUtil.fix(pattern) : pattern;
+    };

package/src/programmers/internal/random_custom.ts

@@ -1,30 +1,30 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { LiteralFactory } from "../../factories/LiteralFactory";
-
-import { ICommentTag } from "../../metadata/ICommentTag";
-
-import { Customizable } from "../../typings/Customizable";
-
-/**
- * @internal
- */
-export const random_custom =
-    (accessor: (name: string) => ts.Expression) =>
-    (type: keyof Customizable) =>
-    (comments: ICommentTag[]) =>
-    (expression: ts.Expression) =>
-        ExpressionFactory.coalesce(
-            ts.factory.createCallChain(
-                ts.factory.createPropertyAccessChain(
-                    accessor("customs"),
-                    ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-                    ts.factory.createIdentifier(type),
-                ),
-                ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-                undefined,
-                [LiteralFactory.generate(comments)],
-            ),
-            expression,
-        );
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { LiteralFactory } from "../../factories/LiteralFactory";
+
+import { ICommentTag } from "../../metadata/ICommentTag";
+
+import { Customizable } from "../../typings/Customizable";
+
+/**
+ * @internal
+ */
+export const random_custom =
+    (accessor: (name: string) => ts.Expression) =>
+    (type: keyof Customizable) =>
+    (comments: ICommentTag[]) =>
+    (expression: ts.Expression) =>
+        ExpressionFactory.coalesce(
+            ts.factory.createCallChain(
+                ts.factory.createPropertyAccessChain(
+                    accessor("customs"),
+                    ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+                    ts.factory.createIdentifier(type),
+                ),
+                ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+                undefined,
+                [LiteralFactory.generate(comments)],
+            ),
+            expression,
+        );

package/src/programmers/internal/stringify_dynamic_properties.ts

@@ -1,168 +1,168 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { TemplateFactory } from "../../factories/TemplateFactory";
-
-import { IExpressionEntry } from "../helpers/IExpressionEntry";
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export function stringify_dynamic_properties(
-    dynamic: IExpressionEntry<ts.Expression>[],
-    regular: string[],
-): ts.Expression {
-    // BASIC STATMEMENT, CHECK UNDEFINED
-    const statements: ts.Statement[] = [
-        ts.factory.createIfStatement(
-            ts.factory.createStrictEquality(
-                ts.factory.createIdentifier("undefined"),
-                ts.factory.createIdentifier("value"),
-            ),
-            ts.factory.createReturnStatement(
-                ts.factory.createStringLiteral(""),
-            ),
-        ),
-    ];
-
-    // PREPARE RETURN FUNCTION
-    const output = () => {
-        const mapped = ts.factory.createCallExpression(
-            IdentifierFactory.join(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("Object.entries"),
-                    undefined,
-                    [ts.factory.createIdentifier("input")],
-                ),
-                "map",
-            ),
-            undefined,
-            [
-                ts.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [
-                        IdentifierFactory.parameter(
-                            ts.factory.createArrayBindingPattern([
-                                ts.factory.createBindingElement(
-                                    undefined,
-                                    undefined,
-                                    "key",
-                                ),
-                                ts.factory.createBindingElement(
-                                    undefined,
-                                    undefined,
-                                    "value",
-                                ),
-                            ]),
-                            ts.factory.createTypeReferenceNode("[string, any]"),
-                        ),
-                    ],
-                    undefined,
-                    undefined,
-                    ts.factory.createBlock(statements),
-                ),
-            ],
-        );
-        const filtered = ts.factory.createCallExpression(
-            IdentifierFactory.join(mapped, "filter"),
-            undefined,
-            [
-                ts.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [IdentifierFactory.parameter("str")],
-                    undefined,
-                    undefined,
-                    ts.factory.createStrictInequality(
-                        ts.factory.createStringLiteral(""),
-                        ts.factory.createIdentifier("str"),
-                    ),
-                ),
-            ],
-        );
-        return ts.factory.createCallExpression(
-            IdentifierFactory.join(filtered, "join"),
-            undefined,
-            [ts.factory.createStringLiteral(",")],
-        );
-    };
-
-    // WHEN REGULAR PROPERTY EXISTS
-    if (regular.length)
-        statements.push(
-            ts.factory.createIfStatement(
-                ts.factory.createCallExpression(
-                    IdentifierFactory.join(
-                        ts.factory.createArrayLiteralExpression(
-                            regular.map((key) =>
-                                ts.factory.createStringLiteral(key),
-                            ),
-                        ),
-                        "some",
-                    ),
-                    undefined,
-                    [
-                        ts.factory.createArrowFunction(
-                            undefined,
-                            undefined,
-                            [IdentifierFactory.parameter("regular")],
-                            undefined,
-                            undefined,
-                            ts.factory.createStrictEquality(
-                                ts.factory.createIdentifier("regular"),
-                                ts.factory.createIdentifier("key"),
-                            ),
-                        ),
-                    ],
-                ),
-                ts.factory.createReturnStatement(
-                    ts.factory.createStringLiteral(""),
-                ),
-            ),
-        );
-
-    // ONLY STRING TYPED KEY EXISTS
-    const simple: boolean =
-        dynamic.length === 1 &&
-        dynamic[0]!.key.size() === 1 &&
-        dynamic[0]!.key.atomics[0] === "string";
-    if (simple === true) {
-        statements.push(stringify(dynamic[0]!));
-        return output();
-    }
-
-    // COMPOSITE TEMPLATE LITERAL TYPES
-    for (const entry of dynamic) {
-        const condition: ts.IfStatement = ts.factory.createIfStatement(
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier(
-                    `RegExp(/${metadata_to_pattern(true)(entry.key)}/).test`,
-                ),
-                undefined,
-                [ts.factory.createIdentifier("key")],
-            ),
-            stringify(entry),
-        );
-        statements.push(condition);
-    }
-    return output();
-}
-
-/**
- * @internal
- */
-function stringify(entry: IExpressionEntry<ts.Expression>): ts.ReturnStatement {
-    return ts.factory.createReturnStatement(
-        TemplateFactory.generate([
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier("JSON.stringify"),
-                [],
-                [ts.factory.createIdentifier("key")],
-            ),
-            ts.factory.createStringLiteral(":"),
-            entry.expression,
-        ]),
-    );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { TemplateFactory } from "../../factories/TemplateFactory";
+
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export function stringify_dynamic_properties(
+    dynamic: IExpressionEntry<ts.Expression>[],
+    regular: string[],
+): ts.Expression {
+    // BASIC STATMEMENT, CHECK UNDEFINED
+    const statements: ts.Statement[] = [
+        ts.factory.createIfStatement(
+            ts.factory.createStrictEquality(
+                ts.factory.createIdentifier("undefined"),
+                ts.factory.createIdentifier("value"),
+            ),
+            ts.factory.createReturnStatement(
+                ts.factory.createStringLiteral(""),
+            ),
+        ),
+    ];
+
+    // PREPARE RETURN FUNCTION
+    const output = () => {
+        const mapped = ts.factory.createCallExpression(
+            IdentifierFactory.join(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("Object.entries"),
+                    undefined,
+                    [ts.factory.createIdentifier("input")],
+                ),
+                "map",
+            ),
+            undefined,
+            [
+                ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
+                    [
+                        IdentifierFactory.parameter(
+                            ts.factory.createArrayBindingPattern([
+                                ts.factory.createBindingElement(
+                                    undefined,
+                                    undefined,
+                                    "key",
+                                ),
+                                ts.factory.createBindingElement(
+                                    undefined,
+                                    undefined,
+                                    "value",
+                                ),
+                            ]),
+                            ts.factory.createTypeReferenceNode("[string, any]"),
+                        ),
+                    ],
+                    undefined,
+                    undefined,
+                    ts.factory.createBlock(statements),
+                ),
+            ],
+        );
+        const filtered = ts.factory.createCallExpression(
+            IdentifierFactory.join(mapped, "filter"),
+            undefined,
+            [
+                ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
+                    [IdentifierFactory.parameter("str")],
+                    undefined,
+                    undefined,
+                    ts.factory.createStrictInequality(
+                        ts.factory.createStringLiteral(""),
+                        ts.factory.createIdentifier("str"),
+                    ),
+                ),
+            ],
+        );
+        return ts.factory.createCallExpression(
+            IdentifierFactory.join(filtered, "join"),
+            undefined,
+            [ts.factory.createStringLiteral(",")],
+        );
+    };
+
+    // WHEN REGULAR PROPERTY EXISTS
+    if (regular.length)
+        statements.push(
+            ts.factory.createIfStatement(
+                ts.factory.createCallExpression(
+                    IdentifierFactory.join(
+                        ts.factory.createArrayLiteralExpression(
+                            regular.map((key) =>
+                                ts.factory.createStringLiteral(key),
+                            ),
+                        ),
+                        "some",
+                    ),
+                    undefined,
+                    [
+                        ts.factory.createArrowFunction(
+                            undefined,
+                            undefined,
+                            [IdentifierFactory.parameter("regular")],
+                            undefined,
+                            undefined,
+                            ts.factory.createStrictEquality(
+                                ts.factory.createIdentifier("regular"),
+                                ts.factory.createIdentifier("key"),
+                            ),
+                        ),
+                    ],
+                ),
+                ts.factory.createReturnStatement(
+                    ts.factory.createStringLiteral(""),
+                ),
+            ),
+        );
+
+    // ONLY STRING TYPED KEY EXISTS
+    const simple: boolean =
+        dynamic.length === 1 &&
+        dynamic[0]!.key.size() === 1 &&
+        dynamic[0]!.key.atomics[0] === "string";
+    if (simple === true) {
+        statements.push(stringify(dynamic[0]!));
+        return output();
+    }
+
+    // COMPOSITE TEMPLATE LITERAL TYPES
+    for (const entry of dynamic) {
+        const condition: ts.IfStatement = ts.factory.createIfStatement(
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier(
+                    `RegExp(/${metadata_to_pattern(true)(entry.key)}/).test`,
+                ),
+                undefined,
+                [ts.factory.createIdentifier("key")],
+            ),
+            stringify(entry),
+        );
+        statements.push(condition);
+    }
+    return output();
+}
+
+/**
+ * @internal
+ */
+function stringify(entry: IExpressionEntry<ts.Expression>): ts.ReturnStatement {
+    return ts.factory.createReturnStatement(
+        TemplateFactory.generate([
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier("JSON.stringify"),
+                [],
+                [ts.factory.createIdentifier("key")],
+            ),
+            ts.factory.createStringLiteral(":"),
+            entry.expression,
+        ]),
+    );
+}