typia 5.0.0-dev.20230821 → 5.0.0-dev.20230822

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, (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"]);

package/src/programmers/helpers/CloneJoiner.ts

@@ -1,107 +1,107 @@
-import ts from "typescript";
-
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { Escaper } from "../../utils/Escaper";
-
-import { metadata_to_pattern } from "../internal/metadata_to_pattern";
-import { IExpressionEntry } from "./IExpressionEntry";
-
-export namespace CloneJoiner {
-    export const object = (
-        input: ts.Expression,
-        entries: IExpressionEntry<ts.Expression>[],
-    ): ts.ConciseBody => {
-        if (entries.length === 0) return ts.factory.createIdentifier("{}");
-
-        const regular = entries.filter((e) => e.key.isSoleLiteral());
-        const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
-        const literal = ts.factory.createObjectLiteralExpression(
-            regular.map((entry) => {
-                const str: string = entry.key.getSoleLiteral()!;
-                return ts.factory.createPropertyAssignment(
-                    Escaper.variable(str)
-                        ? str
-                        : ts.factory.createStringLiteral(str),
-                    entry.expression,
-                );
-            }),
-            true,
-        );
-        if (dynamic.length === 0) return literal;
-
-        const key = ts.factory.createIdentifier("key");
-        const output = ts.factory.createIdentifier("output");
-
-        const statements: ts.Statement[] = dynamic.map((entry) =>
-            ts.factory.createIfStatement(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier(
-                        `RegExp(/${metadata_to_pattern(true)(
-                            entry.key,
-                        )}/).test`,
-                    ),
-                    undefined,
-                    [key],
-                ),
-                ts.factory.createBlock([
-                    ts.factory.createExpressionStatement(
-                        ts.factory.createBinaryExpression(
-                            ts.factory.createElementAccessExpression(
-                                output,
-                                key,
-                            ),
-                            ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-                            entry.expression,
-                        ),
-                    ),
-                    ts.factory.createContinueStatement(),
-                ]),
-            ),
-        );
-
-        return ts.factory.createBlock([
-            StatementFactory.constant(
-                "output",
-                ts.factory.createAsExpression(
-                    literal,
-                    TypeFactory.keyword("any"),
-                ),
-            ),
-            ts.factory.createForOfStatement(
-                undefined,
-                StatementFactory.entry("key")("value"),
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("Object.entries"),
-                    undefined,
-                    [input],
-                ),
-                ts.factory.createBlock(statements),
-            ),
-            ts.factory.createReturnStatement(output),
-        ]);
-    };
-
-    export const tuple = (
-        children: ts.Expression[],
-        rest: ts.Expression | null,
-    ): ts.Expression => {
-        return ts.factory.createAsExpression(
-            ts.factory.createArrayLiteralExpression(
-                rest === null
-                    ? children
-                    : [...children, ts.factory.createSpreadElement(rest)],
-                true,
-            ),
-            TypeFactory.keyword("any"),
-        );
-    };
-
-    export const array = (input: ts.Expression, arrow: ts.Expression) =>
-        ts.factory.createCallExpression(
-            ts.factory.createPropertyAccessExpression(input, "map"),
-            undefined,
-            [arrow],
-        );
-}
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { metadata_to_pattern } from "../internal/metadata_to_pattern";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace CloneJoiner {
+    export const object = (
+        input: ts.Expression,
+        entries: IExpressionEntry<ts.Expression>[],
+    ): ts.ConciseBody => {
+        if (entries.length === 0) return ts.factory.createIdentifier("{}");
+
+        const regular = entries.filter((e) => e.key.isSoleLiteral());
+        const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
+        const literal = ts.factory.createObjectLiteralExpression(
+            regular.map((entry) => {
+                const str: string = entry.key.getSoleLiteral()!;
+                return ts.factory.createPropertyAssignment(
+                    Escaper.variable(str)
+                        ? str
+                        : ts.factory.createStringLiteral(str),
+                    entry.expression,
+                );
+            }),
+            true,
+        );
+        if (dynamic.length === 0) return literal;
+
+        const key = ts.factory.createIdentifier("key");
+        const output = ts.factory.createIdentifier("output");
+
+        const statements: ts.Statement[] = dynamic.map((entry) =>
+            ts.factory.createIfStatement(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier(
+                        `RegExp(/${metadata_to_pattern(true)(
+                            entry.key,
+                        )}/).test`,
+                    ),
+                    undefined,
+                    [key],
+                ),
+                ts.factory.createBlock([
+                    ts.factory.createExpressionStatement(
+                        ts.factory.createBinaryExpression(
+                            ts.factory.createElementAccessExpression(
+                                output,
+                                key,
+                            ),
+                            ts.factory.createToken(ts.SyntaxKind.EqualsToken),
+                            entry.expression,
+                        ),
+                    ),
+                    ts.factory.createContinueStatement(),
+                ]),
+            ),
+        );
+
+        return ts.factory.createBlock([
+            StatementFactory.constant(
+                "output",
+                ts.factory.createAsExpression(
+                    literal,
+                    TypeFactory.keyword("any"),
+                ),
+            ),
+            ts.factory.createForOfStatement(
+                undefined,
+                StatementFactory.entry("key")("value"),
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("Object.entries"),
+                    undefined,
+                    [input],
+                ),
+                ts.factory.createBlock(statements),
+            ),
+            ts.factory.createReturnStatement(output),
+        ]);
+    };
+
+    export const tuple = (
+        children: ts.Expression[],
+        rest: ts.Expression | null,
+    ): ts.Expression => {
+        return ts.factory.createAsExpression(
+            ts.factory.createArrayLiteralExpression(
+                rest === null
+                    ? children
+                    : [...children, ts.factory.createSpreadElement(rest)],
+                true,
+            ),
+            TypeFactory.keyword("any"),
+        );
+    };
+
+    export const array = (input: ts.Expression, arrow: ts.Expression) =>
+        ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(input, "map"),
+            undefined,
+            [arrow],
+        );
+}

package/src/programmers/helpers/FunctionImporeter.ts

@@ -1,89 +1,89 @@
-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 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 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/IExpressionEntry.ts

@@ -1,12 +1,12 @@
-import ts from "typescript";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-export interface IExpressionEntry<
-    Expression extends ts.ConciseBody = ts.ConciseBody,
-> {
-    input: ts.Expression;
-    key: Metadata;
-    meta: Metadata;
-    expression: Expression;
-}
+import ts from "typescript";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+export interface IExpressionEntry<
+    Expression extends ts.ConciseBody = ts.ConciseBody,
+> {
+    input: ts.Expression;
+    key: Metadata;
+    meta: Metadata;
+    expression: Expression;
+}

package/src/programmers/helpers/ProtobufUtil.ts

@@ -1,24 +1,29 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { Atomic } from "../../typings/Atomic";
-
-export namespace ProtobufUtil {
-    export const atomics = (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)!,
-        );
-    };
-}
-
-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 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],
+]);

package/src/programmers/helpers/ProtobufWire.ts

@@ -1,34 +1,34 @@
-export const enum ProtobufWire {
-    /**
-     * - integers
-     * - bool
-     * - enum
-     */
-    VARIANT = 0,
-
-    /**
-     * - fixed64
-     * - sfixed64
-     * - double
-     */
-    I64 = 1,
-
-    /**
-     * - string
-     * - bytes
-     * - mebedded messages
-     * - packed repeated fields
-     */
-    LEN = 2,
-
-    START_GROUP = 3,
-
-    END_GROUP = 4,
-
-    /**
-     * - fixed
-     * - sfixed32
-     * - float
-     */
-    I32 = 5,
-}
+export const enum ProtobufWire {
+    /**
+     * - integers
+     * - bool
+     * - enum
+     */
+    VARIANT = 0,
+
+    /**
+     * - fixed64
+     * - sfixed64
+     * - double
+     */
+    I64 = 1,
+
+    /**
+     * - string
+     * - bytes
+     * - mebedded messages
+     * - packed repeated fields
+     */
+    LEN = 2,
+
+    START_GROUP = 3,
+
+    END_GROUP = 4,
+
+    /**
+     * - fixed
+     * - sfixed32
+     * - float
+     */
+    I32 = 5,
+}