typia 5.1.6 → 5.2.0-dev.20231007

package/src/programmers/helpers/NotationJoiner.ts

@@ -0,0 +1,146 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+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 NotationJoiner {
+    export const object =
+        (rename: (str: string) => string) =>
+        (
+            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 = rename(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[] = [];
+            if (regular.length !== 0)
+                statements.push(
+                    ts.factory.createIfStatement(
+                        ts.factory.createCallExpression(
+                            IdentifierFactory.access(
+                                ts.factory.createArrayLiteralExpression(
+                                    regular.map((r) =>
+                                        ts.factory.createStringLiteral(
+                                            r.key.getSoleLiteral()!,
+                                        ),
+                                    ),
+                                ),
+                            )("some"),
+                            undefined,
+                            [
+                                ts.factory.createArrowFunction(
+                                    undefined,
+                                    undefined,
+                                    [IdentifierFactory.parameter("regular")],
+                                    undefined,
+                                    undefined,
+                                    ts.factory.createStrictEquality(
+                                        ts.factory.createIdentifier("regular"),
+                                        ts.factory.createIdentifier("key"),
+                                    ),
+                                ),
+                            ],
+                        ),
+                        ts.factory.createContinueStatement(),
+                    ),
+                );
+            statements.push(
+                ...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/misc/MiscCloneProgrammer.ts

@@ -124,7 +124,11 @@ export namespace MiscCloneProgrammer {
             if (
                 meta.any ||
                 meta.arrays.some((a) => a.type.value.any) ||
-                meta.tuples.some((t) => t.type.elements.every((e) => e.any))
+                meta.tuples.some(
+                    (t) =>
+                        !!t.type.elements.length &&
+                        t.type.elements.every((e) => e.any),
+                )
             )
                 return ts.factory.createCallExpression(
                     importer.use("any"),
@@ -142,6 +146,18 @@ export namespace MiscCloneProgrammer {
             //----
             // LIST UP UNION TYPES
             //----
+            // FUNCTIONAL
+            if (meta.functional)
+                unions.push({
+                    type: "functional",
+                    is: () =>
+                        ts.factory.createStrictEquality(
+                            ts.factory.createStringLiteral("function"),
+                            ts.factory.createTypeOfExpression(input),
+                        ),
+                    value: () => ts.factory.createIdentifier("undefined"),
+                });
+
             // TUPLES
             for (const tuple of meta.tuples)
                 unions.push({

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -456,8 +456,10 @@ export namespace MiscPruneProgrammer {
     const filter = (meta: Metadata): boolean =>
         meta.any === false &&
         (meta.objects.length !== 0 ||
-            meta.tuples.some((t) =>
-                t.type.elements.some((e) => filter(e.rest ?? e)),
+            meta.tuples.some(
+                (t) =>
+                    !!t.type.elements.length &&
+                    t.type.elements.some((e) => filter(e.rest ?? e)),
             ) ||
             meta.arrays.some((e) => filter(e.type.value)));
 

package/src/programmers/notations/NotationAssertGeneralProgrammer.ts

@@ -0,0 +1,72 @@
+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 { NotationGeneralProgrammer } from "./NotationGeneralProgrammer";
+
+export namespace NotationAssertGeneralProgrammer {
+    export const write =
+        (rename: (str: string) => string) =>
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode(
+                    NotationGeneralProgrammer.returnType(rename)(
+                        name ?? TypeFactory.getFullName(project.checker)(type),
+                    ),
+                ),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "assert",
+                        AssertProgrammer.write(project)(modulo)(false)(
+                            type,
+                            name,
+                        ),
+                    ),
+                    StatementFactory.constant(
+                        "general",
+                        NotationGeneralProgrammer.write(rename)({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    ts.factory.createExpressionStatement(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("assert"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("general"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}