typia 4.1.6-dev.20230213 → 4.1.7-dev.20230715

package/src/programmers/LiteralsProgrammer.ts

@@ -1,62 +1,63 @@
-import ts from "typescript";
-
-import { MetadataCollection } from "../factories/MetadataCollection";
-import { MetadataFactory } from "../factories/MetadataFactory";
-
-import { Metadata } from "../metadata/Metadata";
-
-import { IProject } from "../transformers/IProject";
-
-import { Atomic } from "../typings/Atomic";
-
-import { ArrayUtil } from "../utils/ArrayUtil";
-
-export namespace LiteralsProgrammer {
-    export const write = (project: IProject) => (type: ts.Type) => {
-        const meta: Metadata = MetadataFactory.analyze(project.checker)({
-            resolve: true,
-            constant: true,
-            absorb: true,
-            validate: (meta) => {
-                const length: number =
-                    meta.constants
-                        .map((c) => c.values.length)
-                        .reduce((a, b) => a + b, 0) +
-                    meta.atomics.filter((type) => type === "boolean").length;
-                if (0 === length) throw new Error(ErrorMessages.NO);
-                else if (meta.size() !== length)
-                    throw new Error(ErrorMessages.ONLY);
-            },
-        })(new MetadataCollection())(type);
-        const values: Set<Atomic.Type | null> = new Set([
-            ...ArrayUtil.flat<Atomic.Type>(meta.constants.map((c) => c.values)),
-            ...(meta.atomics.filter((type) => type === "boolean").length
-                ? [true, false]
-                : []),
-            ...meta.nullable ? [null] : []
-        ]);
-        return ts.factory.createAsExpression(
-            ts.factory.createArrayLiteralExpression(
-                [...values].map((v) =>
-                    v === null ? ts.factory.createNull()
-                    : typeof v === "boolean"
-                        ? v
-                            ? ts.factory.createTrue()
-                            : ts.factory.createFalse()
-                        : typeof v === "number"
-                        ? ts.factory.createNumericLiteral(v)
-                        : typeof v === "bigint"
-                        ? ts.factory.createBigIntLiteral(v.toString())
-                        : ts.factory.createStringLiteral(v),
-                ),
-                true,
-            ),
-            ts.factory.createTypeReferenceNode("const"),
-        );
-    };
-}
-
-enum ErrorMessages {
-    NO = "Error on typia.literals(): no literal type found.",
-    ONLY = "Error on typia.literals(): only literal type allowed.",
-}
+import ts from "typescript";
+
+import { MetadataCollection } from "../factories/MetadataCollection";
+import { MetadataFactory } from "../factories/MetadataFactory";
+
+import { Metadata } from "../metadata/Metadata";
+
+import { IProject } from "../transformers/IProject";
+
+import { Atomic } from "../typings/Atomic";
+
+import { ArrayUtil } from "../utils/ArrayUtil";
+
+export namespace LiteralsProgrammer {
+    export const write = (project: IProject) => (type: ts.Type) => {
+        const meta: Metadata = MetadataFactory.analyze(project.checker)({
+            resolve: true,
+            constant: true,
+            absorb: true,
+            validate: (meta) => {
+                const length: number =
+                    meta.constants
+                        .map((c) => c.values.length)
+                        .reduce((a, b) => a + b, 0) +
+                    meta.atomics.filter((type) => type === "boolean").length;
+                if (0 === length) throw new Error(ErrorMessages.NO);
+                else if (meta.size() !== length)
+                    throw new Error(ErrorMessages.ONLY);
+            },
+        })(new MetadataCollection())(type);
+        const values: Set<Atomic.Type | null> = new Set([
+            ...ArrayUtil.flat<Atomic.Type>(meta.constants.map((c) => c.values)),
+            ...(meta.atomics.filter((type) => type === "boolean").length
+                ? [true, false]
+                : []),
+            ...(meta.nullable ? [null] : []),
+        ]);
+        return ts.factory.createAsExpression(
+            ts.factory.createArrayLiteralExpression(
+                [...values].map((v) =>
+                    v === null
+                        ? ts.factory.createNull()
+                        : typeof v === "boolean"
+                        ? v
+                            ? ts.factory.createTrue()
+                            : ts.factory.createFalse()
+                        : typeof v === "number"
+                        ? ts.factory.createNumericLiteral(v)
+                        : typeof v === "bigint"
+                        ? ts.factory.createBigIntLiteral(v.toString())
+                        : ts.factory.createStringLiteral(v),
+                ),
+                true,
+            ),
+            ts.factory.createTypeReferenceNode("const"),
+        );
+    };
+}
+
+enum ErrorMessages {
+    NO = "Error on typia.literals(): no literal type found.",
+    ONLY = "Error on typia.literals(): only literal type allowed.",
+}

package/src/programmers/internal/application_alias.ts

@@ -1,3 +1,6 @@
+import { CommentFactory } from "../../factories/CommentFactory";
+
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 import { MetadataAlias } from "../../metadata/MetadataAlias";
 import { IJsonComponents } from "../../schemas/IJsonComponents";
 
@@ -34,7 +37,25 @@ export const application_alias =
             // GENERATE SCHEM
             const schema: IJsonSchema = application_schema(options)(blockNever)(
                 components,
-            )(alias.value)({})!;
+            )(alias.value)({
+                deprecated:
+                    alias.jsDocTags.some((tag) => tag.name === "deprecated") ||
+                    undefined,
+                title: (() => {
+                    const info: IJsDocTagInfo | undefined =
+                        alias.jsDocTags.find((tag) => tag.name === "title");
+                    return info?.text?.length
+                        ? CommentFactory.merge(info.text)
+                        : undefined;
+                })(),
+                description: alias.description ?? undefined,
+                "x-typia-metaTags": alias.tags.length ? alias.tags : undefined,
+                "x-typia-jsDocTags": alias.jsDocTags.length
+                    ? alias.jsDocTags
+                    : undefined,
+                "x-typia-required": alias.value.required,
+                "x-typia-optional": alias.value.optional,
+            })!;
             components.schemas ??= {};
             components.schemas[key] = {
                 $id: options.purpose === "ajv" ? $id : undefined,

package/src/programmers/internal/application_number.ts

@@ -1,74 +1,74 @@
-import { IJsonSchema } from "../../module";
-import { application_default } from "./application_default";
-
-/**
- * @internal
- */
-export const application_number = (
-    attribute: IJsonSchema.IAttribute,
-): IJsonSchema.INumber | IJsonSchema.IInteger => {
-    const output: IJsonSchema.INumber | IJsonSchema.IInteger = {
-        ...attribute,
-        type: "number" as "number" | "integer",
-    };
-    for (const tag of attribute["x-typia-metaTags"] ?? []) {
-        // CHECK TYPE
-        if (
-            tag.kind === "type" &&
-            (tag.value === "int" ||
-                tag.value === "uint" ||
-                tag.value === "{int}" ||
-                tag.value === "{uint}")
-        )
-            output.type = "integer";
-        // RANGE TAG
-        else if (tag.kind === "minimum") output.minimum = tag.value;
-        else if (tag.kind === "maximum") output.maximum = tag.value;
-        else if (tag.kind === "exclusiveMinimum") {
-            output.minimum = tag.value;
-            output.exclusiveMinimum = true;
-        } else if (tag.kind === "exclusiveMaximum") {
-            output.maximum = tag.value;
-            output.exclusiveMaximum = true;
-        }
-        // MULTIPLE-OF
-        else if (tag.kind === "multipleOf") output.multipleOf = tag.value;
-    }
-
-    // WHEN UNSIGNED INT
-    if (
-        output.type === "integer" &&
-        (attribute["x-typia-metaTags"] ?? []).find(
-            (tag) => tag.kind === "type" && tag.value === "uint",
-        )
-    )
-        if (
-            output.minimum === undefined ||
-            (output.exclusiveMaximum !== true && output.minimum < 0)
-        )
-            output.minimum = 0;
-        else if (output.exclusiveMinimum === true && output.minimum < -1) {
-            output.maximum = 0;
-            delete output.exclusiveMinimum;
-        }
-
-    // DEFAULT CONFIGURATION
-    output.default = application_default(attribute)((str) => {
-        const value: number = Number(str);
-        const conditions: boolean[] = [!Number.isNaN(value)];
-        if (output.minimum !== undefined)
-            if (output.exclusiveMinimum === true)
-                conditions.push(value > output.minimum);
-            else conditions.push(value >= output.minimum);
-        if (output.maximum !== undefined)
-            if (output.exclusiveMaximum === true)
-                conditions.push(value < output.maximum);
-            else conditions.push(value <= output.maximum);
-        if (output.multipleOf !== undefined)
-            conditions.push(value % output.multipleOf === 0);
-        return conditions.every((cond) => cond);
-    })((str) => Number(str));
-
-    // RETURNS
-    return output;
-};
+import { IJsonSchema } from "../../module";
+import { application_default } from "./application_default";
+
+/**
+ * @internal
+ */
+export const application_number = (
+    attribute: IJsonSchema.IAttribute,
+): IJsonSchema.INumber | IJsonSchema.IInteger => {
+    const output: IJsonSchema.INumber | IJsonSchema.IInteger = {
+        ...attribute,
+        type: "number" as "number" | "integer",
+    };
+    for (const tag of attribute["x-typia-metaTags"] ?? []) {
+        // CHECK TYPE
+        if (
+            tag.kind === "type" &&
+            (tag.value === "int" ||
+                tag.value === "uint" ||
+                tag.value === "{int}" ||
+                tag.value === "{uint}")
+        )
+            output.type = "integer";
+        // RANGE TAG
+        else if (tag.kind === "minimum") output.minimum = tag.value;
+        else if (tag.kind === "maximum") output.maximum = tag.value;
+        else if (tag.kind === "exclusiveMinimum") {
+            output.minimum = tag.value;
+            output.exclusiveMinimum = true;
+        } else if (tag.kind === "exclusiveMaximum") {
+            output.maximum = tag.value;
+            output.exclusiveMaximum = true;
+        }
+        // MULTIPLE-OF
+        else if (tag.kind === "multipleOf") output.multipleOf = tag.value;
+    }
+
+    // WHEN UNSIGNED INT
+    if (
+        output.type === "integer" &&
+        (attribute["x-typia-metaTags"] ?? []).find(
+            (tag) => tag.kind === "type" && tag.value === "uint",
+        )
+    )
+        if (
+            output.minimum === undefined ||
+            (output.exclusiveMaximum !== true && output.minimum < 0)
+        )
+            output.minimum = 0;
+        else if (output.exclusiveMinimum === true && output.minimum < -1) {
+            output.maximum = 0;
+            delete output.exclusiveMinimum;
+        }
+
+    // DEFAULT CONFIGURATION
+    output.default = application_default(attribute)((str) => {
+        const value: number = Number(str);
+        const conditions: boolean[] = [!Number.isNaN(value)];
+        if (output.minimum !== undefined)
+            if (output.exclusiveMinimum === true)
+                conditions.push(value > output.minimum);
+            else conditions.push(value >= output.minimum);
+        if (output.maximum !== undefined)
+            if (output.exclusiveMaximum === true)
+                conditions.push(value < output.maximum);
+            else conditions.push(value <= output.maximum);
+        if (output.multipleOf !== undefined)
+            conditions.push(value % output.multipleOf === 0);
+        return conditions.every((cond) => cond);
+    })((str) => Number(str));
+
+    // RETURNS
+    return output;
+};

package/src/programmers/internal/application_object.ts

@@ -55,7 +55,7 @@ export const application_object =
                 true,
             )(components)(property.value)({
                 deprecated:
-                    !!property.jsDocTags.find(
+                    property.jsDocTags.some(
                         (tag) => tag.name === "deprecated",
                     ) || undefined,
                 title: (() => {