typia 5.0.0-dev.20230823-2 → 5.0.0-dev.2023084

package/src/programmers/helpers/AtomicPredicator.ts

@@ -1,31 +1,31 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { Atomic } from "../../typings/Atomic";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
-export namespace AtomicPredicator {
-    export const constant =
-        (meta: Metadata) =>
-        (name: Atomic.Literal): boolean =>
-            !ArrayUtil.has(meta.atomics, (atomic) => atomic === name) &&
-            !ArrayUtil.has(
-                meta.natives,
-                (native) => native.toLowerCase() === name,
-            );
-
-    export const atomic =
-        (meta: Metadata) =>
-        (name: Atomic.Literal): boolean =>
-            !ArrayUtil.has(
-                meta.natives,
-                (native) => native.toLowerCase() === name,
-            );
-
-    export const native = (name: string) => LIKE.has(name.toLowerCase());
-
-    export const template = (meta: Metadata): boolean =>
-        !ArrayUtil.has(meta.atomics, (type) => type === "string");
-}
-
-const LIKE = new Set(["boolean", "number", "string"]);
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { Atomic } from "../../typings/Atomic";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+export namespace AtomicPredicator {
+    export const constant =
+        (meta: Metadata) =>
+        (name: Atomic.Literal): boolean =>
+            !ArrayUtil.has(meta.atomics, (a) => a.type === name) &&
+            !ArrayUtil.has(
+                meta.natives,
+                (native) => native.toLowerCase() === name,
+            );
+
+    export const atomic =
+        (meta: Metadata) =>
+        (name: Atomic.Literal): boolean =>
+            !ArrayUtil.has(
+                meta.natives,
+                (native) => native.toLowerCase() === name,
+            );
+
+    export const native = (name: string) => LIKE.has(name.toLowerCase());
+
+    export const template = (meta: Metadata): boolean =>
+        !ArrayUtil.has(meta.atomics, (a) => a.type === "string");
+}
+
+const LIKE = new Set(["boolean", "number", "string"]);

package/src/programmers/helpers/FunctionImporeter.ts

@@ -1,91 +1,91 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-export class FunctionImporter {
-    private readonly used_: Set<string> = new Set();
-    private readonly local_: Set<string> = new Set();
-    private readonly unions_: Map<string, [string, ts.ArrowFunction]> =
-        new Map();
-    private sequence_: number = 0;
-
-    public constructor(public readonly method: string) {}
-
-    public empty(): boolean {
-        return this.used_.size === 0;
-    }
-
-    public use(name: string): ts.Identifier {
-        this.used_.add(name);
-        return ts.factory.createIdentifier("$" + name);
-    }
-
-    public useLocal(name: string): string {
-        this.local_.add(name);
-        return name;
-    }
-
-    public hasLocal(name: string): boolean {
-        return this.local_.has(name);
-    }
-
-    public declare(
-        modulo: ts.LeftHandSideExpression,
-        includeUnions: boolean = true,
-    ): ts.Statement[] {
-        return [
-            ...[...this.used_].map((name) =>
-                StatementFactory.constant(
-                    "$" + name,
-                    IdentifierFactory.access(
-                        ts.factory.createParenthesizedExpression(
-                            ts.factory.createAsExpression(
-                                modulo,
-                                TypeFactory.keyword("any"),
-                            ),
-                        ),
-                    )(name),
-                ),
-            ),
-            ...(includeUnions === true
-                ? [...this.unions_.values()].map(([key, arrow]) =>
-                      StatementFactory.constant(key, arrow),
-                  )
-                : []),
-        ];
-    }
-
-    public declareUnions(): ts.Statement[] {
-        return [...this.unions_.values()].map(([key, arrow]) =>
-            StatementFactory.constant(key, arrow),
-        );
-    }
-
-    public increment(): number {
-        return ++this.sequence_;
-    }
-
-    public emplaceUnion(
-        prefix: string,
-        name: string,
-        factory: () => ts.ArrowFunction,
-    ): string {
-        const oldbie = this.unions_.get(name);
-        if (oldbie) return oldbie[0];
-
-        const index: number = this.unions_.size;
-        const accessor: string = `${prefix}p${index}`;
-
-        const tuple: [string, ReturnType<typeof factory>] = [accessor, null!];
-        this.unions_.set(name, tuple);
-        tuple[1] = factory();
-        return accessor;
-    }
-
-    public trace(): void {
-        console.log(...this.used_);
-        console.log(...this.local_);
-    }
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+export class FunctionImporter {
+    private readonly used_: Set<string> = new Set();
+    private readonly local_: Set<string> = new Set();
+    private readonly unions_: Map<string, [string, ts.ArrowFunction]> =
+        new Map();
+    private sequence_: number = 0;
+
+    public constructor(public readonly method: string) {}
+
+    public empty(): boolean {
+        return this.used_.size === 0;
+    }
+
+    public use(name: string): ts.Identifier {
+        this.used_.add(name);
+        return ts.factory.createIdentifier("$" + name);
+    }
+
+    public useLocal(name: string): string {
+        this.local_.add(name);
+        return name;
+    }
+
+    public hasLocal(name: string): boolean {
+        return this.local_.has(name);
+    }
+
+    public declare(
+        modulo: ts.LeftHandSideExpression,
+        includeUnions: boolean = true,
+    ): ts.Statement[] {
+        return [
+            ...[...this.used_].map((name) =>
+                StatementFactory.constant(
+                    "$" + name,
+                    IdentifierFactory.access(
+                        ts.factory.createParenthesizedExpression(
+                            ts.factory.createAsExpression(
+                                modulo,
+                                TypeFactory.keyword("any"),
+                            ),
+                        ),
+                    )(name),
+                ),
+            ),
+            ...(includeUnions === true
+                ? [...this.unions_.values()].map(([key, arrow]) =>
+                      StatementFactory.constant(key, arrow),
+                  )
+                : []),
+        ];
+    }
+
+    public declareUnions(): ts.Statement[] {
+        return [...this.unions_.values()].map(([key, arrow]) =>
+            StatementFactory.constant(key, arrow),
+        );
+    }
+
+    public increment(): number {
+        return ++this.sequence_;
+    }
+
+    public emplaceUnion(
+        prefix: string,
+        name: string,
+        factory: () => ts.ArrowFunction,
+    ): string {
+        const oldbie = this.unions_.get(name);
+        if (oldbie) return oldbie[0];
+
+        const index: number = this.unions_.size;
+        const accessor: string = `${prefix}p${index}`;
+
+        const tuple: [string, ReturnType<typeof factory>] = [accessor, null!];
+        this.unions_.set(name, tuple);
+        tuple[1] = factory();
+        return accessor;
+    }
+
+    public trace(): void {
+        console.log(...this.used_);
+        console.log(...this.local_);
+    }
+}

package/src/programmers/helpers/ProtobufUtil.ts

@@ -1,29 +1,29 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { Atomic } from "../../typings/Atomic";
-
-export namespace ProtobufUtil {
-    export const getAtomics = (meta: Metadata) => {
-        const set: Set<Atomic.Literal> = new Set();
-
-        for (const atomic of meta.atomics) set.add(atomic);
-        for (const constant of meta.constants) set.add(constant.type);
-        if (meta.templates.length) set.add("string");
-
-        return [...set].sort(
-            (x, y) => ATOMIC_ORDER.get(x)! - ATOMIC_ORDER.get(y)!,
-        );
-    };
-
-    export const isStaticObject = (obj: MetadataObject): boolean =>
-        obj.properties.length >= 1 &&
-        obj.properties.every((p) => p.key.isSoleLiteral());
-}
-
-const ATOMIC_ORDER = new Map<Atomic.Literal, number>([
-    ["boolean", 0],
-    ["bigint", 1],
-    ["number", 2],
-    ["string", 3],
-]);
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+
+import { Atomic } from "../../typings/Atomic";
+
+export namespace ProtobufUtil {
+    export const getAtomics = (meta: Metadata) => {
+        const set: Set<Atomic.Literal> = new Set();
+
+        for (const a of meta.atomics) set.add(a.type);
+        for (const constant of meta.constants) set.add(constant.type);
+        if (meta.templates.length) set.add("string");
+
+        return [...set].sort(
+            (x, y) => ATOMIC_ORDER.get(x)! - ATOMIC_ORDER.get(y)!,
+        );
+    };
+
+    export const isStaticObject = (obj: MetadataObject): boolean =>
+        obj.properties.length >= 1 &&
+        obj.properties.every((p) => p.key.isSoleLiteral());
+}
+
+const ATOMIC_ORDER = new Map<Atomic.Literal, number>([
+    ["boolean", 0],
+    ["bigint", 1],
+    ["number", 2],
+    ["string", 3],
+]);

package/src/programmers/helpers/StringifyPredicator.ts

@@ -1,12 +1,12 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-export namespace StringifyPredicator {
-    export const require_escape = (value: string): boolean =>
-        value.split("").some((ch) => ESCAPED.some((escaped) => escaped === ch));
-
-    export const undefindable = (meta: Metadata): boolean =>
-        meta.isRequired() === false ||
-        (meta.escaped !== null && meta.escaped.returns.isRequired() === false);
-
-    const ESCAPED = ['"', "\\", "\b", "\f", "\n", "\n", "\r", "\t"];
-}
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+export namespace StringifyPredicator {
+    export const require_escape = (value: string): boolean =>
+        value.split("").some((ch) => ESCAPED.some((escaped) => escaped === ch));
+
+    export const undefindable = (meta: Metadata): boolean =>
+        meta.isRequired() === false ||
+        (meta.escaped !== null && meta.escaped.returns.isRequired() === false);
+
+    const ESCAPED = ['"', "\\", "\b", "\f", "\n", "\n", "\r", "\t"];
+}

package/src/programmers/helpers/disable_function_importer_declare.ts

@@ -1,32 +1,32 @@
-import ts from "typescript";
-
-import { FunctionImporter } from "./FunctionImporeter";
-
-export const disable_function_importer_declare = (
-    importer: FunctionImporter,
-): FunctionImporter => disable(importer) as FunctionImporter;
-
-const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
-    method: importer.method,
-    empty: (): boolean => importer.empty(),
-    use: (name: string): ts.Identifier => importer.use(name),
-    useLocal: (name: string): string => importer.useLocal(name),
-    hasLocal: (name: string): boolean => importer.hasLocal(name),
-    declare: (_modulo: ts.LeftHandSideExpression): ts.Statement[] => [],
-    declareUnions: (): ts.Statement[] => [],
-    increment: (): number => importer.increment(),
-    emplaceUnion: (
-        prefix: string,
-        name: string,
-        factory: () => ts.ArrowFunction,
-    ): string => importer.emplaceUnion(prefix, name, factory),
-    trace: (): void => importer.trace(),
-});
-
-type MethodOnly<T> = {
-    [P in keyof T]: T[P] extends Function
-        ? T[P]
-        : P extends "method"
-        ? T[P]
-        : never;
-};
+import ts from "typescript";
+
+import { FunctionImporter } from "./FunctionImporeter";
+
+export const disable_function_importer_declare = (
+    importer: FunctionImporter,
+): FunctionImporter => disable(importer) as FunctionImporter;
+
+const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
+    method: importer.method,
+    empty: (): boolean => importer.empty(),
+    use: (name: string): ts.Identifier => importer.use(name),
+    useLocal: (name: string): string => importer.useLocal(name),
+    hasLocal: (name: string): boolean => importer.hasLocal(name),
+    declare: (_modulo: ts.LeftHandSideExpression): ts.Statement[] => [],
+    declareUnions: (): ts.Statement[] => [],
+    increment: (): number => importer.increment(),
+    emplaceUnion: (
+        prefix: string,
+        name: string,
+        factory: () => ts.ArrowFunction,
+    ): string => importer.emplaceUnion(prefix, name, factory),
+    trace: (): void => importer.trace(),
+});
+
+type MethodOnly<T> = {
+    [P in keyof T]: T[P] extends Function
+        ? T[P]
+        : P extends "method"
+        ? T[P]
+        : never;
+};

package/src/programmers/internal/application_default_string.ts

@@ -1,33 +1,37 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { IJsonSchema } from "../../module";
-import { application_default } from "./application_default";
-
-/**
- * @internal
- */
-export const application_default_string =
-    (meta: Metadata) =>
-    (attribute: IJsonSchema.IAttribute) =>
-    (schema: IJsonSchema.IString) =>
-        application_default(attribute)((str) => {
-            const conditions: boolean[] = [];
-
-            // OTHER ATOMIC TYPES
-            if (meta.atomics.find((t) => t === "number" || t === "bigint"))
-                conditions.push(Number.isNaN(Number(str)));
-            if (meta.atomics.find((t) => t === "boolean"))
-                conditions.push(str !== "true" && str !== "false");
-            for (const constant of meta.constants)
-                for (const value of constant.values)
-                    conditions.push(str !== value.toString());
-
-            // CONSIDER TAGS
-            if (schema.minLength !== undefined)
-                conditions.push(str.length >= schema.minLength);
-            if (schema.maxLength !== undefined)
-                conditions.push(str.length <= schema.maxLength);
-            if (schema.pattern !== undefined)
-                conditions.push(new RegExp(schema.pattern).test(str));
-            return conditions.every((c) => c);
-        })((str) => str);
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { IJsonSchema } from "../../module";
+import { application_default } from "./application_default";
+
+/**
+ * @internal
+ */
+export const application_default_string =
+    (meta: Metadata) =>
+    (attribute: IJsonSchema.IAttribute) =>
+    (schema: IJsonSchema.IString) =>
+        application_default(attribute)((str) => {
+            const conditions: boolean[] = [];
+
+            // OTHER ATOMIC TYPES
+            if (
+                meta.atomics.find(
+                    (a) => a.type === "number" || a.type === "bigint",
+                )
+            )
+                conditions.push(Number.isNaN(Number(str)));
+            if (meta.atomics.find((a) => a.type === "boolean"))
+                conditions.push(str !== "true" && str !== "false");
+            for (const constant of meta.constants)
+                for (const value of constant.values)
+                    conditions.push(str !== value.toString());
+
+            // CONSIDER TAGS
+            if (schema.minLength !== undefined)
+                conditions.push(str.length >= schema.minLength);
+            if (schema.maxLength !== undefined)
+                conditions.push(str.length <= schema.maxLength);
+            if (schema.pattern !== undefined)
+                conditions.push(new RegExp(schema.pattern).test(str));
+            return conditions.every((c) => c);
+        })((str) => str);

package/src/programmers/internal/application_resolved.ts

@@ -1,55 +1,55 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
-
-import { IJsonComponents, IJsonSchema } from "../../module";
-import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
-import { application_schema } from "./application_schema";
-
-export const application_resolved =
-    (options: JsonApplicationProgrammer.IOptions) =>
-    <BlockNever extends boolean>(blockNever: BlockNever) =>
-    (components: IJsonComponents) =>
-    (resolved: MetadataEscaped) =>
-    (attribute: IJsonSchema.IAttribute): IJsonSchema[] => {
-        const output = application_schema(options)(blockNever)(components)(
-            resolved.returns,
-        )(attribute);
-        if (output === null) return [];
-
-        if (is_date(new Set())(resolved.original)) {
-            const string: IJsonSchema.IString | undefined = is_string(output)
-                ? output
-                : is_one_of(output)
-                ? output.oneOf.find(is_string)
-                : undefined;
-            if (
-                string !== undefined &&
-                string.format !== "date" &&
-                string.format !== "date-time"
-            )
-                string.format = "date-time";
-        }
-        return is_one_of(output) ? output.oneOf : [output];
-    };
-
-const is_string = (elem: IJsonSchema): elem is IJsonSchema.IString =>
-    (elem as IJsonSchema.IString).type === "string";
-
-const is_one_of = (elem: IJsonSchema): elem is IJsonSchema.IOneOf =>
-    Array.isArray((elem as IJsonSchema.IOneOf).oneOf);
-
-const is_date =
-    (visited: Set<Metadata>) =>
-    (meta: Metadata): boolean => {
-        if (visited.has(meta)) return false;
-        visited.add(meta);
-
-        return (
-            meta.natives.some((name) => name === "Date") ||
-            meta.arrays.some((array) => is_date(visited)(array.value)) ||
-            meta.tuples.some((tuple) =>
-                tuple.elements.some(is_date(visited)),
-            ) ||
-            meta.aliases.some((alias) => is_date(visited)(alias.value))
-        );
-    };
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
+
+import { IJsonComponents, IJsonSchema } from "../../module";
+import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
+import { application_schema } from "./application_schema";
+
+export const application_resolved =
+    (options: JsonApplicationProgrammer.IOptions) =>
+    <BlockNever extends boolean>(blockNever: BlockNever) =>
+    (components: IJsonComponents) =>
+    (resolved: MetadataEscaped) =>
+    (attribute: IJsonSchema.IAttribute): IJsonSchema[] => {
+        const output = application_schema(options)(blockNever)(components)(
+            resolved.returns,
+        )(attribute);
+        if (output === null) return [];
+
+        if (is_date(new Set())(resolved.original)) {
+            const string: IJsonSchema.IString | undefined = is_string(output)
+                ? output
+                : is_one_of(output)
+                ? output.oneOf.find(is_string)
+                : undefined;
+            if (
+                string !== undefined &&
+                string.format !== "date" &&
+                string.format !== "date-time"
+            )
+                string.format = "date-time";
+        }
+        return is_one_of(output) ? output.oneOf : [output];
+    };
+
+const is_string = (elem: IJsonSchema): elem is IJsonSchema.IString =>
+    (elem as IJsonSchema.IString).type === "string";
+
+const is_one_of = (elem: IJsonSchema): elem is IJsonSchema.IOneOf =>
+    Array.isArray((elem as IJsonSchema.IOneOf).oneOf);
+
+const is_date =
+    (visited: Set<Metadata>) =>
+    (meta: Metadata): boolean => {
+        if (visited.has(meta)) return false;
+        visited.add(meta);
+
+        return (
+            meta.natives.some((name) => name === "Date") ||
+            meta.arrays.some((array) => is_date(visited)(array.value)) ||
+            meta.tuples.some((tuple) =>
+                tuple.elements.some(is_date(visited)),
+            ) ||
+            meta.aliases.some((alias) => is_date(visited)(alias.value))
+        );
+    };