typia 3.4.13 → 3.4.14

package/src/factories/IdentifierFactory.ts

@@ -1,72 +1,72 @@
-import ts from "typescript";
-
-import { Escaper } from "../utils/Escaper";
-
-export namespace IdentifierFactory {
-    export function generate(name: string) {
-        return Escaper.variable(name)
-            ? ts.factory.createIdentifier(name)
-            : ts.factory.createStringLiteral(name);
-    }
-
-    export function join(prefix: ts.Expression, name: string) {
-        const postfix = generate(name);
-        return ts.isStringLiteral(postfix)
-            ? ts.factory.createElementAccessExpression(prefix, postfix)
-            : ts.factory.createPropertyAccessExpression(prefix, postfix);
-    }
-
-    export function postfix(str: string): string {
-        return Escaper.variable(str)
-            ? `".${str}"`
-            : `"[${JSON.stringify(str).split('"').join('\\"')}]"`;
-    }
-
-    export function parameter(
-        name: string | ts.BindingName,
-        init?: ts.Expression,
-    ) {
-        if (ts.version >= "4.8")
-            return ts.factory.createParameterDeclaration(
-                undefined,
-                undefined,
-                name,
-                undefined,
-                undefined,
-                init,
-            );
-        // eslint-disable-next-line
-        return ts.factory.createParameterDeclaration(
-            undefined,
-            undefined,
-            undefined,
-            name,
-            undefined,
-            undefined,
-            init,
-        );
-    }
-
-    // export function property(
-    //     name: string | ts.PropertyName,
-    //     value: ts.Expression,
-    // ): ts.PropertyDeclaration {
-    //     if (ts.version >= "4.8")
-    //         return ts.factory.createPropertyDeclaration(
-    //             undefined,
-    //             name,
-    //             undefined,
-    //             undefined,
-    //             value,
-    //         );
-    //     // eslint-disable-next-line
-    //     return ts.factory.createPropertyDeclaration(
-    //         undefined,
-    //         undefined,
-    //         name,
-    //         undefined,
-    //         undefined,
-    //         value,
-    //     );
-    // }
-}
+import ts from "typescript";
+
+import { Escaper } from "../utils/Escaper";
+
+export namespace IdentifierFactory {
+    export function generate(name: string) {
+        return Escaper.variable(name)
+            ? ts.factory.createIdentifier(name)
+            : ts.factory.createStringLiteral(name);
+    }
+
+    export function join(prefix: ts.Expression, name: string) {
+        const postfix = generate(name);
+        return ts.isStringLiteral(postfix)
+            ? ts.factory.createElementAccessExpression(prefix, postfix)
+            : ts.factory.createPropertyAccessExpression(prefix, postfix);
+    }
+
+    export function postfix(str: string): string {
+        return Escaper.variable(str)
+            ? `".${str}"`
+            : `"[${JSON.stringify(str).split('"').join('\\"')}]"`;
+    }
+
+    export function parameter(
+        name: string | ts.BindingName,
+        init?: ts.Expression,
+    ) {
+        if (ts.version >= "4.8")
+            return ts.factory.createParameterDeclaration(
+                undefined,
+                undefined,
+                name,
+                undefined,
+                undefined,
+                init,
+            );
+        // eslint-disable-next-line
+        return ts.factory.createParameterDeclaration(
+            undefined,
+            undefined,
+            undefined,
+            name,
+            undefined,
+            undefined,
+            init,
+        );
+    }
+
+    // export function property(
+    //     name: string | ts.PropertyName,
+    //     value: ts.Expression,
+    // ): ts.PropertyDeclaration {
+    //     if (ts.version >= "4.8")
+    //         return ts.factory.createPropertyDeclaration(
+    //             undefined,
+    //             name,
+    //             undefined,
+    //             undefined,
+    //             value,
+    //         );
+    //     // eslint-disable-next-line
+    //     return ts.factory.createPropertyDeclaration(
+    //         undefined,
+    //         undefined,
+    //         name,
+    //         undefined,
+    //         undefined,
+    //         value,
+    //     );
+    // }
+}

package/src/factories/LiteralFactory.ts

@@ -1,44 +1,44 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "./IdentifierFactory";
-
-export namespace LiteralFactory {
-    export function generate(input: any): ts.Expression {
-        if (input === null) return ts.factory.createNull();
-        else if (ts.isIdentifier(input)) return input;
-        else if (input instanceof Array) return generate_array(input);
-        else if (typeof input === "object") return generate_object(input);
-        else if (typeof input === "string") return generate_string(input);
-        else if (typeof input === "boolean") return generate_value(input);
-        else if (typeof input === "number") return generate_value(input);
-        else if (typeof input === "bigint") return generate_value(input);
-        else throw new Error("Unknown type.");
-    }
-
-    function generate_object(obj: object): ts.ObjectLiteralExpression {
-        const properties = Object.entries(obj)
-            .filter((tuple) => tuple[1] !== undefined)
-            .map(([key, value]) =>
-                ts.factory.createPropertyAssignment(
-                    IdentifierFactory.generate(key),
-                    generate(value),
-                ),
-            );
-        return ts.factory.createObjectLiteralExpression(properties, true);
-    }
-
-    function generate_array(array: any[]): ts.ArrayLiteralExpression {
-        return ts.factory.createArrayLiteralExpression(
-            array.map(generate),
-            true,
-        );
-    }
-
-    function generate_value(value: number | boolean | bigint): ts.Identifier {
-        return ts.factory.createIdentifier(value.toString());
-    }
-
-    function generate_string(value: string): ts.StringLiteral {
-        return ts.factory.createStringLiteral(value);
-    }
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "./IdentifierFactory";
+
+export namespace LiteralFactory {
+    export function generate(input: any): ts.Expression {
+        if (input === null) return ts.factory.createNull();
+        else if (ts.isIdentifier(input)) return input;
+        else if (input instanceof Array) return generate_array(input);
+        else if (typeof input === "object") return generate_object(input);
+        else if (typeof input === "string") return generate_string(input);
+        else if (typeof input === "boolean") return generate_value(input);
+        else if (typeof input === "number") return generate_value(input);
+        else if (typeof input === "bigint") return generate_value(input);
+        else throw new Error("Unknown type.");
+    }
+
+    function generate_object(obj: object): ts.ObjectLiteralExpression {
+        const properties = Object.entries(obj)
+            .filter((tuple) => tuple[1] !== undefined)
+            .map(([key, value]) =>
+                ts.factory.createPropertyAssignment(
+                    IdentifierFactory.generate(key),
+                    generate(value),
+                ),
+            );
+        return ts.factory.createObjectLiteralExpression(properties, true);
+    }
+
+    function generate_array(array: any[]): ts.ArrayLiteralExpression {
+        return ts.factory.createArrayLiteralExpression(
+            array.map(generate),
+            true,
+        );
+    }
+
+    function generate_value(value: number | boolean | bigint): ts.Identifier {
+        return ts.factory.createIdentifier(value.toString());
+    }
+
+    function generate_string(value: string): ts.StringLiteral {
+        return ts.factory.createStringLiteral(value);
+    }
+}

package/src/factories/MetadataCollection.ts

@@ -1,122 +1,122 @@
-import ts from "typescript";
-
-import { Metadata } from "../metadata/Metadata";
-import { MetadataObject } from "../metadata/MetadataObject";
-
-import { MapUtil } from "../utils/MapUtil";
-
-import { CommentFactory } from "./CommentFactory";
-import { TypeFactory } from "./TypeFactory";
-
-export class MetadataCollection {
-    private readonly dict_: Map<ts.Type, MetadataObject>;
-    private readonly names_: Map<string, Map<ts.Type, string>>;
-    private readonly unions_: Map<string, MetadataObject[]>;
-    private index_: number;
-
-    public constructor(
-        private readonly options?: Partial<MetadataCollection.IOptions>,
-    ) {
-        this.dict_ = new Map();
-        this.names_ = new Map();
-        this.unions_ = new Map();
-        this.index_ = 0;
-    }
-
-    public objects(): MetadataObject[] {
-        return [...this.dict_.values()];
-    }
-    public unions(): MetadataObject[][] {
-        return [...this.unions_.values()];
-    }
-
-    public emplace(
-        checker: ts.TypeChecker,
-        type: ts.Type,
-    ): [MetadataObject, boolean] {
-        const oldbie = this.dict_.get(type);
-        if (oldbie !== undefined) return [oldbie, false];
-
-        const $id: string = this.get_name(checker, type);
-        const obj: MetadataObject = MetadataObject.create({
-            name: $id,
-            properties: [],
-            description:
-                (type.symbol &&
-                    CommentFactory.generate(
-                        type.symbol.getDocumentationComment(checker),
-                    )) ||
-                undefined,
-            jsDocTags: type.symbol?.getJsDocTags() || [],
-            validated: false,
-            index: this.index_++,
-            recursive: false,
-            nullables: [],
-        });
-        this.dict_.set(type, obj);
-        return [obj, true];
-    }
-
-    /**
-     * @internal
-     */
-    public getUnionIndex(meta: Metadata): number {
-        const key: string = meta.objects.map((obj) => obj.name).join(" | ");
-        MapUtil.take(this.unions_, key, () => meta.objects);
-        return [...this.unions_.keys()].indexOf(key);
-    }
-
-    private get_name(checker: ts.TypeChecker, type: ts.Type): string {
-        const name: string = (() => {
-            const str: string = TypeFactory.getFullName(checker, type);
-            return this.options?.replace ? this.options.replace(str) : str;
-        })();
-
-        const duplicates: Map<ts.Type, string> = MapUtil.take(
-            this.names_,
-            name,
-            () => new Map(),
-        );
-        const oldbie: string | undefined = duplicates.get(type);
-        if (oldbie !== undefined) return oldbie;
-
-        const addicted: string = duplicates.size
-            ? `${name}.o${duplicates.size}`
-            : name;
-        duplicates.set(type, addicted);
-        return addicted;
-    }
-}
-export namespace MetadataCollection {
-    export interface IOptions {
-        replace?(str: string): string;
-    }
-
-    export function replace(str: string): string {
-        for (const [before, after] of REPLACERS)
-            str = str.split(before).join(after);
-        return str;
-    }
-
-    export function escape(str: string): string {
-        for (const [before, after] of REPLACERS)
-            if (after !== "") str = str.split(after).join(before);
-        return str;
-    }
-}
-const REPLACERS: [string, string][] = [
-    ["$", "_dollar_"],
-    ["&", "_and_"],
-    ["|", "_or_"],
-    ["{", "_blt_"],
-    ["}", "_bgt_"],
-    ["<", "_lt_"],
-    [">", "_gt_"],
-    ["[", "_alt_"],
-    ["]", "_agt_"],
-    [",", "_comma_"],
-    ["`", "_backquote_"],
-    ["'", "_singlequote_"],
-    ['"', "_doublequote_"],
-    [" ", "_space_"],
-];
+import ts from "typescript";
+
+import { Metadata } from "../metadata/Metadata";
+import { MetadataObject } from "../metadata/MetadataObject";
+
+import { MapUtil } from "../utils/MapUtil";
+
+import { CommentFactory } from "./CommentFactory";
+import { TypeFactory } from "./TypeFactory";
+
+export class MetadataCollection {
+    private readonly dict_: Map<ts.Type, MetadataObject>;
+    private readonly names_: Map<string, Map<ts.Type, string>>;
+    private readonly unions_: Map<string, MetadataObject[]>;
+    private index_: number;
+
+    public constructor(
+        private readonly options?: Partial<MetadataCollection.IOptions>,
+    ) {
+        this.dict_ = new Map();
+        this.names_ = new Map();
+        this.unions_ = new Map();
+        this.index_ = 0;
+    }
+
+    public objects(): MetadataObject[] {
+        return [...this.dict_.values()];
+    }
+    public unions(): MetadataObject[][] {
+        return [...this.unions_.values()];
+    }
+
+    public emplace(
+        checker: ts.TypeChecker,
+        type: ts.Type,
+    ): [MetadataObject, boolean] {
+        const oldbie = this.dict_.get(type);
+        if (oldbie !== undefined) return [oldbie, false];
+
+        const $id: string = this.get_name(checker, type);
+        const obj: MetadataObject = MetadataObject.create({
+            name: $id,
+            properties: [],
+            description:
+                (type.symbol &&
+                    CommentFactory.generate(
+                        type.symbol.getDocumentationComment(checker),
+                    )) ||
+                undefined,
+            jsDocTags: type.symbol?.getJsDocTags() || [],
+            validated: false,
+            index: this.index_++,
+            recursive: false,
+            nullables: [],
+        });
+        this.dict_.set(type, obj);
+        return [obj, true];
+    }
+
+    /**
+     * @internal
+     */
+    public getUnionIndex(meta: Metadata): number {
+        const key: string = meta.objects.map((obj) => obj.name).join(" | ");
+        MapUtil.take(this.unions_, key, () => meta.objects);
+        return [...this.unions_.keys()].indexOf(key);
+    }
+
+    private get_name(checker: ts.TypeChecker, type: ts.Type): string {
+        const name: string = (() => {
+            const str: string = TypeFactory.getFullName(checker, type);
+            return this.options?.replace ? this.options.replace(str) : str;
+        })();
+
+        const duplicates: Map<ts.Type, string> = MapUtil.take(
+            this.names_,
+            name,
+            () => new Map(),
+        );
+        const oldbie: string | undefined = duplicates.get(type);
+        if (oldbie !== undefined) return oldbie;
+
+        const addicted: string = duplicates.size
+            ? `${name}.o${duplicates.size}`
+            : name;
+        duplicates.set(type, addicted);
+        return addicted;
+    }
+}
+export namespace MetadataCollection {
+    export interface IOptions {
+        replace?(str: string): string;
+    }
+
+    export function replace(str: string): string {
+        for (const [before, after] of REPLACERS)
+            str = str.split(before).join(after);
+        return str;
+    }
+
+    export function escape(str: string): string {
+        for (const [before, after] of REPLACERS)
+            if (after !== "") str = str.split(after).join(before);
+        return str;
+    }
+}
+const REPLACERS: [string, string][] = [
+    ["$", "_dollar_"],
+    ["&", "_and_"],
+    ["|", "_or_"],
+    ["{", "_blt_"],
+    ["}", "_bgt_"],
+    ["<", "_lt_"],
+    [">", "_gt_"],
+    ["[", "_alt_"],
+    ["]", "_agt_"],
+    [",", "_comma_"],
+    ["`", "_backquote_"],
+    ["'", "_singlequote_"],
+    ['"', "_doublequote_"],
+    [" ", "_space_"],
+];

package/src/factories/MetadataFactory.ts

@@ -1,46 +1,46 @@
-import ts from "typescript";
-
-import { Metadata } from "../metadata/Metadata";
-
-import { ArrayUtil } from "../utils/ArrayUtil";
-
-import { MetadataCollection } from "./MetadataCollection";
-import { explore_metadata } from "./internal/explore_metadata";
-
-export namespace MetadataFactory {
-    export interface IOptions {
-        resolve: boolean;
-        constant: boolean;
-    }
-
-    export function generate(
-        checker: ts.TypeChecker,
-        collection: MetadataCollection,
-        type: ts.Type | null,
-        options: IOptions,
-    ): Metadata {
-        // CONSTRUCT SCHEMA WITH OBJECTS
-        const metadata: Metadata = explore_metadata(checker)(options)(
-            collection,
-        )(type, false);
-
-        // FIND RECURSIVE OBJECTS
-        for (const object of collection.objects())
-            object.recursive = object.properties.some(
-                (prop) =>
-                    ArrayUtil.has(
-                        prop.value.objects,
-                        (elem) => elem.name === object.name,
-                    ) ||
-                    prop.value.arrays.some((meta) =>
-                        ArrayUtil.has(
-                            meta.objects,
-                            (elem) => elem.name === object.name,
-                        ),
-                    ),
-            );
-
-        // RETURNS
-        return metadata;
-    }
-}
+import ts from "typescript";
+
+import { Metadata } from "../metadata/Metadata";
+
+import { ArrayUtil } from "../utils/ArrayUtil";
+
+import { MetadataCollection } from "./MetadataCollection";
+import { explore_metadata } from "./internal/explore_metadata";
+
+export namespace MetadataFactory {
+    export interface IOptions {
+        resolve: boolean;
+        constant: boolean;
+    }
+
+    export function generate(
+        checker: ts.TypeChecker,
+        collection: MetadataCollection,
+        type: ts.Type | null,
+        options: IOptions,
+    ): Metadata {
+        // CONSTRUCT SCHEMA WITH OBJECTS
+        const metadata: Metadata = explore_metadata(checker)(options)(
+            collection,
+        )(type, false);
+
+        // FIND RECURSIVE OBJECTS
+        for (const object of collection.objects())
+            object.recursive = object.properties.some(
+                (prop) =>
+                    ArrayUtil.has(
+                        prop.value.objects,
+                        (elem) => elem.name === object.name,
+                    ) ||
+                    prop.value.arrays.some((meta) =>
+                        ArrayUtil.has(
+                            meta.objects,
+                            (elem) => elem.name === object.name,
+                        ),
+                    ),
+            );
+
+        // RETURNS
+        return metadata;
+    }
+}