typia 5.0.4 → 5.0.5-dev.20230921

package/src/programmers/internal/stringify_dynamic_properties.ts

@@ -1,171 +1,171 @@
-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 const 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.access(
-                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.access(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.access(filtered)("join"),
-            undefined,
-            [ts.factory.createStringLiteral(",")],
-        );
-    };
-
-    // WHEN REGULAR PROPERTY EXISTS
-    if (regular.length)
-        statements.push(
-            ts.factory.createIfStatement(
-                ts.factory.createCallExpression(
-                    IdentifierFactory.access(
-                        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]?.type === "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);
-    }
-    statements.push(
-        ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
-    );
-
-    return output();
-};
-
-/**
- * @internal
- */
-const stringify = (
-    entry: IExpressionEntry<ts.Expression>,
-): ts.ReturnStatement =>
-    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 const 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.access(
+                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.access(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.access(filtered)("join"),
+            undefined,
+            [ts.factory.createStringLiteral(",")],
+        );
+    };
+
+    // WHEN REGULAR PROPERTY EXISTS
+    if (regular.length)
+        statements.push(
+            ts.factory.createIfStatement(
+                ts.factory.createCallExpression(
+                    IdentifierFactory.access(
+                        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]?.type === "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);
+    }
+    statements.push(
+        ts.factory.createReturnStatement(ts.factory.createStringLiteral("")),
+    );
+
+    return output();
+};
+
+/**
+ * @internal
+ */
+const stringify = (
+    entry: IExpressionEntry<ts.Expression>,
+): ts.ReturnStatement =>
+    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,7 +1,7 @@
-import ts from "typescript";
-
-/**
- * @internal
- */
-export const stringify_native = (): ts.Expression =>
-    ts.factory.createStringLiteral("{}");
+import ts from "typescript";
+
+/**
+ * @internal
+ */
+export const stringify_native = (): ts.Expression =>
+    ts.factory.createStringLiteral("{}");

package/src/programmers/internal/stringify_regular_properties.ts

@@ -1,83 +1,83 @@
-import ts from "typescript";
-
-import { TemplateFactory } from "../../factories/TemplateFactory";
-import { ValueFactory } from "../../factories/ValueFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { IExpressionEntry } from "../helpers/IExpressionEntry";
-
-/**
- * @internal
- */
-export const stringify_regular_properties = (
-    regular: IExpressionEntry<ts.Expression>[],
-    dynamic: IExpressionEntry<ts.Expression>[],
-): ts.Expression[] => {
-    const output: ts.Expression[] = [];
-
-    regular.sort((x, y) => sequence(x.meta) - sequence(y.meta));
-    regular.forEach((entry, index) => {
-        // BASE ELEMENTS
-        const key: string = entry.key.getSoleLiteral()!;
-        const base: ts.Expression[] = [
-            ts.factory.createStringLiteral(`${JSON.stringify(key)}:`),
-            entry.expression,
-        ];
-        if (index !== regular.length - 1 || dynamic.length !== 0)
-            base.push(ts.factory.createStringLiteral(`,`));
-
-        const empty: boolean =
-            (entry.meta.isRequired() === false &&
-                entry.meta.nullable === false &&
-                entry.meta.size() === 0) ||
-            (entry.meta.functional &&
-                entry.meta.nullable === false &&
-                entry.meta.size() === 1);
-
-        if (empty === true) return;
-        else if (
-            entry.meta.isRequired() === false ||
-            entry.meta.functional === true ||
-            entry.meta.any === true
-        )
-            output.push(
-                ts.factory.createConditionalExpression(
-                    (() => {
-                        const conditions: ts.BinaryExpression[] = [];
-                        if (entry.meta.isRequired() === false || entry.meta.any)
-                            conditions.push(
-                                ts.factory.createStrictEquality(
-                                    ts.factory.createIdentifier("undefined"),
-                                    entry.input,
-                                ),
-                            );
-                        if (entry.meta.functional || entry.meta.any)
-                            conditions.push(
-                                ts.factory.createStrictEquality(
-                                    ts.factory.createStringLiteral("function"),
-                                    ValueFactory.TYPEOF(entry.input),
-                                ),
-                            );
-                        return conditions.length === 1
-                            ? conditions[0]!
-                            : conditions.reduce((x, y) =>
-                                  ts.factory.createLogicalOr(x, y),
-                              );
-                    })(),
-                    undefined,
-                    ts.factory.createStringLiteral(""),
-                    undefined,
-                    TemplateFactory.generate(base),
-                ),
-            );
-        else output.push(...base);
-    });
-    return output;
-};
-
-/**
- * @internal
- */
-const sequence = (meta: Metadata): number =>
-    meta.any || !meta.isRequired() || meta.functional ? 0 : 1;
+import ts from "typescript";
+
+import { TemplateFactory } from "../../factories/TemplateFactory";
+import { ValueFactory } from "../../factories/ValueFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { IExpressionEntry } from "../helpers/IExpressionEntry";
+
+/**
+ * @internal
+ */
+export const stringify_regular_properties = (
+    regular: IExpressionEntry<ts.Expression>[],
+    dynamic: IExpressionEntry<ts.Expression>[],
+): ts.Expression[] => {
+    const output: ts.Expression[] = [];
+
+    regular.sort((x, y) => sequence(x.meta) - sequence(y.meta));
+    regular.forEach((entry, index) => {
+        // BASE ELEMENTS
+        const key: string = entry.key.getSoleLiteral()!;
+        const base: ts.Expression[] = [
+            ts.factory.createStringLiteral(`${JSON.stringify(key)}:`),
+            entry.expression,
+        ];
+        if (index !== regular.length - 1 || dynamic.length !== 0)
+            base.push(ts.factory.createStringLiteral(`,`));
+
+        const empty: boolean =
+            (entry.meta.isRequired() === false &&
+                entry.meta.nullable === false &&
+                entry.meta.size() === 0) ||
+            (entry.meta.functional &&
+                entry.meta.nullable === false &&
+                entry.meta.size() === 1);
+
+        if (empty === true) return;
+        else if (
+            entry.meta.isRequired() === false ||
+            entry.meta.functional === true ||
+            entry.meta.any === true
+        )
+            output.push(
+                ts.factory.createConditionalExpression(
+                    (() => {
+                        const conditions: ts.BinaryExpression[] = [];
+                        if (entry.meta.isRequired() === false || entry.meta.any)
+                            conditions.push(
+                                ts.factory.createStrictEquality(
+                                    ts.factory.createIdentifier("undefined"),
+                                    entry.input,
+                                ),
+                            );
+                        if (entry.meta.functional || entry.meta.any)
+                            conditions.push(
+                                ts.factory.createStrictEquality(
+                                    ts.factory.createStringLiteral("function"),
+                                    ValueFactory.TYPEOF(entry.input),
+                                ),
+                            );
+                        return conditions.length === 1
+                            ? conditions[0]!
+                            : conditions.reduce((x, y) =>
+                                  ts.factory.createLogicalOr(x, y),
+                              );
+                    })(),
+                    undefined,
+                    ts.factory.createStringLiteral(""),
+                    undefined,
+                    TemplateFactory.generate(base),
+                ),
+            );
+        else output.push(...base);
+    });
+    return output;
+};
+
+/**
+ * @internal
+ */
+const sequence = (meta: Metadata): number =>
+    meta.any || !meta.isRequired() || meta.functional ? 0 : 1;

package/src/programmers/internal/template_to_pattern.ts

@@ -1,15 +1,15 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { PatternUtil } from "../../utils/PatternUtil";
-
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export const template_to_pattern = (top: boolean) => (template: Metadata[]) => {
-    const pattern: string = template
-        .map((meta) => metadata_to_pattern(false)(meta))
-        .join("");
-    return top ? PatternUtil.fix(pattern) : pattern;
-};
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { PatternUtil } from "../../utils/PatternUtil";
+
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const template_to_pattern = (top: boolean) => (template: Metadata[]) => {
+    const pattern: string = template
+        .map((meta) => metadata_to_pattern(false)(meta))
+        .join("");
+    return top ? PatternUtil.fix(pattern) : pattern;
+};

package/src/programmers/internal/wrap_metadata_rest_tuple.ts

@@ -1,20 +1,20 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../schemas/metadata/MetadataArray";
-import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
-
-export const wrap_metadata_rest_tuple = (rest: Metadata) => {
-    const wrapper: Metadata = Metadata.initialize();
-    wrapper.arrays.push(
-        MetadataArray.create({
-            type: MetadataArrayType.create({
-                name: `...${rest.getName()}`,
-                value: rest,
-                nullables: [],
-                recursive: false,
-                index: null,
-            }),
-            tags: [],
-        }),
-    );
-    return wrapper;
-};
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
+
+export const wrap_metadata_rest_tuple = (rest: Metadata) => {
+    const wrapper: Metadata = Metadata.initialize();
+    wrapper.arrays.push(
+        MetadataArray.create({
+            type: MetadataArrayType.create({
+                name: `...${rest.getName()}`,
+                value: rest,
+                nullables: [],
+                recursive: false,
+                index: null,
+            }),
+            tags: [],
+        }),
+    );
+    return wrapper;
+};