typia 5.0.0-dev.20230820-2 → 5.0.0-dev.20230821

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

package/src/programmers/json/JsonApplicationProgrammer.ts

@@ -1,47 +1,47 @@
-import { IJsonApplication } from "../../schemas/json/IJsonApplication";
-import { IJsonComponents } from "../../schemas/json/IJsonComponents";
-import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { application_schema } from "../internal/application_schema";
-
-export namespace JsonApplicationProgrammer {
-    export interface IOptions {
-        purpose: "ajv" | "swagger";
-    }
-
-    /**
-     * @internal
-     */
-    export namespace IOptions {
-        export const complement = (options?: Partial<IOptions>): IOptions => {
-            const purpose: "swagger" | "ajv" = options?.purpose ?? "swagger";
-            return {
-                purpose,
-            };
-        };
-    }
-
-    export const write =
-        (options?: Partial<IOptions>) =>
-        (metadatas: Array<Metadata>): IJsonApplication => {
-            const fullOptions: IOptions = IOptions.complement(options);
-            const components: IJsonComponents = {
-                schemas: {},
-            };
-            const generator = application_schema(fullOptions)(true)(components);
-
-            return {
-                schemas: metadatas.map((meta, i) => {
-                    const schema: IJsonSchema | null = generator(meta)({});
-                    if (schema === null)
-                        throw new Error(
-                            `Error on typia.application(): invalid type on argument - (${meta.getName()}, ${i})`,
-                        );
-                    return schema;
-                }),
-                components,
-                ...fullOptions,
-            };
-        };
-}
+import { IJsonApplication } from "../../schemas/json/IJsonApplication";
+import { IJsonComponents } from "../../schemas/json/IJsonComponents";
+import { IJsonSchema } from "../../schemas/json/IJsonSchema";
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { application_schema } from "../internal/application_schema";
+
+export namespace JsonApplicationProgrammer {
+    export interface IOptions {
+        purpose: "ajv" | "swagger";
+    }
+
+    /**
+     * @internal
+     */
+    export namespace IOptions {
+        export const complement = (options?: Partial<IOptions>): IOptions => {
+            const purpose: "swagger" | "ajv" = options?.purpose ?? "swagger";
+            return {
+                purpose,
+            };
+        };
+    }
+
+    export const write =
+        (options?: Partial<IOptions>) =>
+        (metadatas: Array<Metadata>): IJsonApplication => {
+            const fullOptions: IOptions = IOptions.complement(options);
+            const components: IJsonComponents = {
+                schemas: {},
+            };
+            const generator = application_schema(fullOptions)(true)(components);
+
+            return {
+                schemas: metadatas.map((meta, i) => {
+                    const schema: IJsonSchema | null = generator(meta)({});
+                    if (schema === null)
+                        throw new Error(
+                            `Error on typia.application(): invalid type on argument - (${meta.getName()}, ${i})`,
+                        );
+                    return schema;
+                }),
+                components,
+                ...fullOptions,
+            };
+        };
+}

package/src/programmers/json/JsonAssertParseProgrammer.ts

@@ -1,66 +1,66 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-
-export namespace JsonAssertParseProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        TypeFactory.keyword("string"),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode(
-                    `typia.Primitive<${
-                        name ?? TypeFactory.getFullName(project.checker)(type)
-                    }>`,
-                ),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "assert",
-                        AssertProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    ts.factory.createExpressionStatement(
-                        ts.factory.createBinaryExpression(
-                            ts.factory.createIdentifier("input"),
-                            ts.SyntaxKind.EqualsToken,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("JSON.parse"),
-                                undefined,
-                                [ts.factory.createIdentifier("input")],
-                            ),
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createAsExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("assert"),
-                                undefined,
-                                [ts.factory.createIdentifier("input")],
-                            ),
-                            ts.factory.createTypeReferenceNode("any"),
-                        ),
-                    ),
-                ]),
-            );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+
+export namespace JsonAssertParseProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("string"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode(
+                    `typia.Primitive<${
+                        name ?? TypeFactory.getFullName(project.checker)(type)
+                    }>`,
+                ),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "assert",
+                        AssertProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    ts.factory.createExpressionStatement(
+                        ts.factory.createBinaryExpression(
+                            ts.factory.createIdentifier("input"),
+                            ts.SyntaxKind.EqualsToken,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("JSON.parse"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("assert"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                            ts.factory.createTypeReferenceNode("any"),
+                        ),
+                    ),
+                ]),
+            );
+}

package/src/programmers/json/JsonAssertStringifyProgrammer.ts

@@ -1,66 +1,66 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
-
-export namespace JsonAssertStringifyProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        TypeFactory.keyword("any"),
-                    ),
-                ],
-                TypeFactory.keyword("string"),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "assert",
-                        AssertProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: true,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "stringify",
-                        JsonStringifyProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("stringify"),
-                            undefined,
-                            [
-                                ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("assert"),
-                                    undefined,
-                                    [ts.factory.createIdentifier("input")],
-                                ),
-                            ],
-                        ),
-                    ),
-                ]),
-            );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
+
+export namespace JsonAssertStringifyProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                TypeFactory.keyword("string"),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "assert",
+                        AssertProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: true,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "stringify",
+                        JsonStringifyProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("stringify"),
+                            undefined,
+                            [
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("assert"),
+                                    undefined,
+                                    [ts.factory.createIdentifier("input")],
+                                ),
+                            ],
+                        ),
+                    ),
+                ]),
+            );
+}