typia 3.4.21 → 3.4.23

package/src/programmers/internal/feature_object_entries.ts

@@ -1,49 +1,49 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { MetadataObject } from "../../metadata/MetadataObject";
-
-import { Escaper } from "../../utils/Escaper";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-
-export const feature_object_entries =
-    (config: Pick<FeatureProgrammer.IConfig, "decoder" | "path" | "trace">) =>
-    (obj: MetadataObject) =>
-    (input: ts.Expression) =>
-        obj.properties.map((prop) => {
-            const sole: string | null = prop.key.getSoleLiteral();
-            const propInput =
-                sole === null
-                    ? ts.factory.createIdentifier("value")
-                    : Escaper.variable(sole)
-                    ? ts.factory.createPropertyAccessExpression(
-                          input,
-                          ts.factory.createIdentifier(sole),
-                      )
-                    : ts.factory.createElementAccessExpression(
-                          input,
-                          ts.factory.createStringLiteral(sole),
-                      );
-
-            return {
-                input: propInput,
-                key: prop.key,
-                meta: prop.value,
-                expression: config.decoder(
-                    propInput,
-                    prop.value,
-                    {
-                        tracable: config.path || config.trace,
-                        source: "object",
-                        from: "object",
-                        postfix:
-                            sole !== null
-                                ? IdentifierFactory.postfix(sole)
-                                : `$join(key)`,
-                    },
-                    prop.tags,
-                ),
-            };
-        });
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { MetadataObject } from "../../metadata/MetadataObject";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+
+export const feature_object_entries =
+    (config: Pick<FeatureProgrammer.IConfig, "decoder" | "path" | "trace">) =>
+    (obj: MetadataObject) =>
+    (input: ts.Expression) =>
+        obj.properties.map((prop) => {
+            const sole: string | null = prop.key.getSoleLiteral();
+            const propInput =
+                sole === null
+                    ? ts.factory.createIdentifier("value")
+                    : Escaper.variable(sole)
+                    ? ts.factory.createPropertyAccessExpression(
+                          input,
+                          ts.factory.createIdentifier(sole),
+                      )
+                    : ts.factory.createElementAccessExpression(
+                          input,
+                          ts.factory.createStringLiteral(sole),
+                      );
+
+            return {
+                input: propInput,
+                key: prop.key,
+                meta: prop.value,
+                expression: config.decoder(
+                    propInput,
+                    prop.value,
+                    {
+                        tracable: config.path || config.trace,
+                        source: "object",
+                        from: "object",
+                        postfix:
+                            sole !== null
+                                ? IdentifierFactory.postfix(sole)
+                                : `$join(key)`,
+                    },
+                    prop.tags,
+                ),
+            };
+        });

package/src/programmers/internal/metadata_to_pattern.ts

@@ -1,31 +1,31 @@
-import { Metadata } from "../../metadata/Metadata";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-import { PatternUtil } from "../../utils/PatternUtil";
-
-import { template_to_pattern } from "./template_to_pattern";
-
-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";
+
+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/stringify_dynamic_properties.ts

@@ -1,164 +1,164 @@
-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[],
-    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",
-                                ),
-                            ]),
-                        ),
-                    ],
-                    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();
-}
-
-function stringify(entry: IExpressionEntry): 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[],
+    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",
+                                ),
+                            ]),
+                        ),
+                    ],
+                    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();
+}
+
+function stringify(entry: IExpressionEntry): 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,
+        ]),
+    );
+}

package/src/programmers/internal/stringify_native.ts

@@ -1,8 +1,8 @@
-import ts from "typescript";
-
-/**
- * @internal
- */
-export function stringify_native(): ts.Expression {
-    return ts.factory.createStringLiteral("{}");
-}
+import ts from "typescript";
+
+/**
+ * @internal
+ */
+export function stringify_native(): ts.Expression {
+    return ts.factory.createStringLiteral("{}");
+}