typia 5.0.4 → 5.0.5-dev.20230921

package/src/programmers/internal/decode_union_object.ts

@@ -1,84 +1,84 @@
-import ts from "typescript";
-
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-
-/**
- * @internal
- */
-export const decode_union_object =
-    (
-        checker: (
-            input: ts.Expression,
-            obj: MetadataObject,
-            explore: FeatureProgrammer.IExplore,
-        ) => ts.Expression,
-    ) =>
-    (
-        decoder: (
-            input: ts.Expression,
-            obj: MetadataObject,
-            explore: FeatureProgrammer.IExplore,
-        ) => ts.Expression,
-    ) =>
-    (success: (exp: ts.Expression) => ts.Expression) =>
-    (escaper: (value: ts.Expression, expected: string) => ts.Statement) =>
-    (
-        input: ts.Expression,
-        targets: MetadataObject[],
-        explore: FeatureProgrammer.IExplore,
-    ): ts.CallExpression =>
-        ts.factory.createCallExpression(
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [],
-                undefined,
-                undefined,
-                iterate(escaper)(
-                    input,
-                    targets.map((obj) => ({
-                        type: "object",
-                        is: () => success(checker(input, obj, explore)),
-                        value: () => decoder(input, obj, explore),
-                    })),
-                    `(${targets.map((t) => t.name).join(" | ")})`,
-                ),
-            ),
-            undefined,
-            undefined,
-        );
-
-const iterate =
-    (escaper: (value: ts.Expression, expected: string) => ts.Statement) =>
-    (input: ts.Expression, unions: IUnion[], expected: string) =>
-        ts.factory.createBlock(
-            [
-                unions
-                    .map((u, i) =>
-                        ts.factory.createIfStatement(
-                            u.is(),
-                            ts.factory.createReturnStatement(u.value()),
-                            i === unions.length - 1
-                                ? escaper(input, expected)
-                                : undefined,
-                        ),
-                    )
-                    .reverse()
-                    .reduce((a, b) =>
-                        ts.factory.createIfStatement(
-                            b.expression,
-                            b.thenStatement,
-                            a,
-                        ),
-                    ),
-            ],
-            true,
-        );
-
-interface IUnion {
-    type: string;
-    is: () => ts.Expression;
-    value: () => ts.Expression;
-}
+import ts from "typescript";
+
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+
+/**
+ * @internal
+ */
+export const decode_union_object =
+    (
+        checker: (
+            input: ts.Expression,
+            obj: MetadataObject,
+            explore: FeatureProgrammer.IExplore,
+        ) => ts.Expression,
+    ) =>
+    (
+        decoder: (
+            input: ts.Expression,
+            obj: MetadataObject,
+            explore: FeatureProgrammer.IExplore,
+        ) => ts.Expression,
+    ) =>
+    (success: (exp: ts.Expression) => ts.Expression) =>
+    (escaper: (value: ts.Expression, expected: string) => ts.Statement) =>
+    (
+        input: ts.Expression,
+        targets: MetadataObject[],
+        explore: FeatureProgrammer.IExplore,
+    ): ts.CallExpression =>
+        ts.factory.createCallExpression(
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [],
+                undefined,
+                undefined,
+                iterate(escaper)(
+                    input,
+                    targets.map((obj) => ({
+                        type: "object",
+                        is: () => success(checker(input, obj, explore)),
+                        value: () => decoder(input, obj, explore),
+                    })),
+                    `(${targets.map((t) => t.name).join(" | ")})`,
+                ),
+            ),
+            undefined,
+            undefined,
+        );
+
+const iterate =
+    (escaper: (value: ts.Expression, expected: string) => ts.Statement) =>
+    (input: ts.Expression, unions: IUnion[], expected: string) =>
+        ts.factory.createBlock(
+            [
+                unions
+                    .map((u, i) =>
+                        ts.factory.createIfStatement(
+                            u.is(),
+                            ts.factory.createReturnStatement(u.value()),
+                            i === unions.length - 1
+                                ? escaper(input, expected)
+                                : undefined,
+                        ),
+                    )
+                    .reverse()
+                    .reduce((a, b) =>
+                        ts.factory.createIfStatement(
+                            b.expression,
+                            b.thenStatement,
+                            a,
+                        ),
+                    ),
+            ],
+            true,
+        );
+
+interface IUnion {
+    type: string;
+    is: () => ts.Expression;
+    value: () => ts.Expression;
+}

package/src/programmers/internal/feature_object_entries.ts

@@ -1,58 +1,58 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { Escaper } from "../../utils/Escaper";
-
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-
-/**
- * @internal
- */
-export const feature_object_entries =
-    <Output extends ts.ConciseBody>(
-        config: Pick<
-            FeatureProgrammer.IConfig<Output>,
-            "decoder" | "path" | "trace"
-        >,
-    ) =>
-    (importer: FunctionImporter) =>
-    (obj: MetadataObject) =>
-    (input: ts.Expression, from: "object" | "top" | "array" = "object") =>
-        obj.properties.map((prop) => {
-            const sole: string | null = prop.key.getSoleLiteral();
-            const propInput =
-                sole === null
-                    ? ts.factory.createIdentifier("value")
-                    : Escaper.variable(sole)
-                    ? ts.factory.createPropertyAccessExpression(
-                          input,
-                          ts.factory.createIdentifier(sole),
-                      )
-                    : ts.factory.createElementAccessExpression(
-                          input,
-                          ts.factory.createStringLiteral(sole),
-                      );
-
-            return {
-                input: propInput,
-                key: prop.key,
-                meta: prop.value,
-                expression: config.decoder()(propInput, prop.value, {
-                    tracable: config.path || config.trace,
-                    source: "function",
-                    from,
-                    postfix: config.trace
-                        ? sole !== null
-                            ? IdentifierFactory.postfix(sole)
-                            : (() => {
-                                  importer.use("join");
-                                  return `$join(key)`;
-                              })()
-                        : "",
-                }),
-            };
-        });
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+
+/**
+ * @internal
+ */
+export const feature_object_entries =
+    <Output extends ts.ConciseBody>(
+        config: Pick<
+            FeatureProgrammer.IConfig<Output>,
+            "decoder" | "path" | "trace"
+        >,
+    ) =>
+    (importer: FunctionImporter) =>
+    (obj: MetadataObject) =>
+    (input: ts.Expression, from: "object" | "top" | "array" = "object") =>
+        obj.properties.map((prop) => {
+            const sole: string | null = prop.key.getSoleLiteral();
+            const propInput =
+                sole === null
+                    ? ts.factory.createIdentifier("value")
+                    : Escaper.variable(sole)
+                    ? ts.factory.createPropertyAccessExpression(
+                          input,
+                          ts.factory.createIdentifier(sole),
+                      )
+                    : ts.factory.createElementAccessExpression(
+                          input,
+                          ts.factory.createStringLiteral(sole),
+                      );
+
+            return {
+                input: propInput,
+                key: prop.key,
+                meta: prop.value,
+                expression: config.decoder()(propInput, prop.value, {
+                    tracable: config.path || config.trace,
+                    source: "function",
+                    from,
+                    postfix: config.trace
+                        ? sole !== null
+                            ? IdentifierFactory.postfix(sole)
+                            : (() => {
+                                  importer.use("join");
+                                  return `$join(key)`;
+                              })()
+                        : "",
+                }),
+            };
+        });

package/src/programmers/internal/metadata_to_pattern.ts

@@ -1,34 +1,34 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-import { PatternUtil } from "../../utils/PatternUtil";
-
-import { template_to_pattern } from "./template_to_pattern";
-
-/**
- * @internal
- */
-export const metadata_to_pattern =
-    (top: boolean) =>
-    (meta: Metadata): string => {
-        if (meta.atomics.find((a) => a.type === "string") !== undefined)
-            return "(.*)";
-
-        const values: string[] = ArrayUtil.flat(
-            meta.constants.map((c) => {
-                if (c.type !== "string")
-                    return c.values.map((v) => v.toString());
-                return c.values.map((str) => PatternUtil.escape(str));
-            }),
-        );
-        for (const a of meta.atomics)
-            if (a.type === "number" || a.type === "bigint")
-                values.push(PatternUtil.NUMBER);
-            else if (a.type === "boolean") values.push(PatternUtil.BOOLEAN);
-        for (const childTpl of meta.templates)
-            values.push("(" + template_to_pattern(false)(childTpl) + ")");
-
-        const pattern: string =
-            values.length === 1 ? values[0]! : "(" + values.join("|") + ")";
-        return top ? PatternUtil.fix(pattern) : pattern;
-    };
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+import { PatternUtil } from "../../utils/PatternUtil";
+
+import { template_to_pattern } from "./template_to_pattern";
+
+/**
+ * @internal
+ */
+export const metadata_to_pattern =
+    (top: boolean) =>
+    (meta: Metadata): string => {
+        if (meta.atomics.find((a) => a.type === "string") !== undefined)
+            return "(.*)";
+
+        const values: string[] = ArrayUtil.flat(
+            meta.constants.map((c) => {
+                if (c.type !== "string")
+                    return c.values.map((v) => v.toString());
+                return c.values.map((str) => PatternUtil.escape(str));
+            }),
+        );
+        for (const a of meta.atomics)
+            if (a.type === "number" || a.type === "bigint")
+                values.push(PatternUtil.NUMBER);
+            else if (a.type === "boolean") values.push(PatternUtil.BOOLEAN);
+        for (const childTpl of meta.templates)
+            values.push("(" + template_to_pattern(false)(childTpl) + ")");
+
+        const pattern: string =
+            values.length === 1 ? values[0]! : "(" + values.join("|") + ")";
+        return top ? PatternUtil.fix(pattern) : pattern;
+    };

package/src/programmers/internal/prune_object_properties.ts

@@ -1,60 +1,60 @@
-import ts from "typescript";
-
-import { StatementFactory } from "../../factories/StatementFactory";
-
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { metadata_to_pattern } from "./metadata_to_pattern";
-
-/**
- * @internal
- */
-export const prune_object_properties = (obj: MetadataObject) => {
-    const input: ts.Expression = ts.factory.createIdentifier("input");
-    const key: ts.Expression = ts.factory.createIdentifier("key");
-
-    const condition: ts.Expression[] = obj.properties.map((prop) => {
-        const name: string | null = prop.key.getSoleLiteral();
-        if (name !== null)
-            return ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral(name),
-                ts.factory.createIdentifier("key"),
-            );
-        return ts.factory.createCallExpression(
-            ts.factory.createIdentifier(
-                `RegExp(/${metadata_to_pattern(true)(prop.key)}/).test`,
-            ),
-            undefined,
-            [key],
-        );
-    });
-
-    const statements: ts.Statement[] = [];
-    if (condition.length)
-        statements.push(
-            ts.factory.createIfStatement(
-                condition.reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-                ts.factory.createContinueStatement(),
-            ),
-        );
-    statements.push(
-        ts.factory.createExpressionStatement(
-            ts.factory.createDeleteExpression(
-                ts.factory.createElementAccessExpression(input, key),
-            ),
-        ),
-    );
-
-    return ts.factory.createForOfStatement(
-        undefined,
-        StatementFactory.constant("key").declarationList,
-        ts.factory.createCallExpression(
-            ts.factory.createIdentifier("Object.keys"),
-            undefined,
-            [input],
-        ),
-        statements.length === 1
-            ? statements[0]!
-            : ts.factory.createBlock(statements, true),
-    );
-};
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+
+import { metadata_to_pattern } from "./metadata_to_pattern";
+
+/**
+ * @internal
+ */
+export const prune_object_properties = (obj: MetadataObject) => {
+    const input: ts.Expression = ts.factory.createIdentifier("input");
+    const key: ts.Expression = ts.factory.createIdentifier("key");
+
+    const condition: ts.Expression[] = obj.properties.map((prop) => {
+        const name: string | null = prop.key.getSoleLiteral();
+        if (name !== null)
+            return ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral(name),
+                ts.factory.createIdentifier("key"),
+            );
+        return ts.factory.createCallExpression(
+            ts.factory.createIdentifier(
+                `RegExp(/${metadata_to_pattern(true)(prop.key)}/).test`,
+            ),
+            undefined,
+            [key],
+        );
+    });
+
+    const statements: ts.Statement[] = [];
+    if (condition.length)
+        statements.push(
+            ts.factory.createIfStatement(
+                condition.reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+                ts.factory.createContinueStatement(),
+            ),
+        );
+    statements.push(
+        ts.factory.createExpressionStatement(
+            ts.factory.createDeleteExpression(
+                ts.factory.createElementAccessExpression(input, key),
+            ),
+        ),
+    );
+
+    return ts.factory.createForOfStatement(
+        undefined,
+        StatementFactory.constant("key").declarationList,
+        ts.factory.createCallExpression(
+            ts.factory.createIdentifier("Object.keys"),
+            undefined,
+            [input],
+        ),
+        statements.length === 1
+            ? statements[0]!
+            : ts.factory.createBlock(statements, true),
+    );
+};

package/src/programmers/internal/random_custom.ts

@@ -1,37 +1,37 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { LiteralFactory } from "../../factories/LiteralFactory";
-
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-
-import { Customizable } from "../../typings/Customizable";
-
-/**
- * @internal
- */
-export const random_custom =
-    (accessor: (name: string) => ts.Expression) =>
-    (type: keyof Customizable) =>
-    (tags: IMetadataTypeTag[]) =>
-    (expression: ts.Expression) =>
-        ExpressionFactory.coalesce(
-            ts.factory.createCallChain(
-                ts.factory.createPropertyAccessChain(
-                    accessor("customs"),
-                    ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-                    ts.factory.createIdentifier(type),
-                ),
-                ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-                undefined,
-                [
-                    LiteralFactory.generate(
-                        tags.map((t) => ({
-                            name: t.name,
-                            kind: t.kind,
-                            value: t.value,
-                        })),
-                    ),
-                ],
-            ),
-        )(expression);
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { LiteralFactory } from "../../factories/LiteralFactory";
+
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+
+import { Customizable } from "../../typings/Customizable";
+
+/**
+ * @internal
+ */
+export const random_custom =
+    (accessor: (name: string) => ts.Expression) =>
+    (type: keyof Customizable) =>
+    (tags: IMetadataTypeTag[]) =>
+    (expression: ts.Expression) =>
+        ExpressionFactory.coalesce(
+            ts.factory.createCallChain(
+                ts.factory.createPropertyAccessChain(
+                    accessor("customs"),
+                    ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+                    ts.factory.createIdentifier(type),
+                ),
+                ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+                undefined,
+                [
+                    LiteralFactory.generate(
+                        tags.map((t) => ({
+                            name: t.name,
+                            kind: t.kind,
+                            value: t.value,
+                        })),
+                    ),
+                ],
+            ),
+        )(expression);