typia 5.2.4 → 5.2.5

package/src/programmers/AssertProgrammer.ts

@@ -91,8 +91,8 @@ export namespace AssertProgrammer {
                                   ),
                               ]),
                     ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
-                combiner: combiner(equals)(importer),
-                joiner: joiner(equals)(importer),
+                combiner: combiner(equals)(project)(importer),
+                joiner: joiner(equals)(project)(importer),
                 success: ts.factory.createTrue(),
                 addition: () => importer.declare(modulo),
             })(importer)(type, name);
@@ -148,13 +148,14 @@ export namespace AssertProgrammer {
 
     const combiner =
         (equals: boolean) =>
+        (project: IProject) =>
         (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
         (explore: CheckerProgrammer.IExplore) => {
             if (explore.tracable === false)
                 return IsProgrammer.configure({
-                    object: assert_object(equals)(importer),
+                    object: assert_object(equals)(project)(importer),
                     numeric: true,
-                })(importer).combiner(explore);
+                })(project)(importer).combiner(explore);
 
             const path: string = explore.postfix
                 ? `_path + ${explore.postfix}`
@@ -219,40 +220,44 @@ export namespace AssertProgrammer {
             //   })();
         };
 
-    const assert_object = (equals: boolean) => (importer: FunctionImporter) =>
-        check_object({
-            equals,
-            assert: true,
-            undefined: true,
-            reduce: ts.factory.createLogicalAnd,
-            positive: ts.factory.createTrue(),
-            superfluous: (value) =>
-                create_guard_call(importer)()(
-                    ts.factory.createAdd(
-                        ts.factory.createIdentifier("_path"),
-                        ts.factory.createCallExpression(
-                            importer.use("join"),
-                            undefined,
-                            [ts.factory.createIdentifier("key")],
+    const assert_object =
+        (equals: boolean) =>
+        (project: IProject) =>
+        (importer: FunctionImporter) =>
+            check_object({
+                equals,
+                assert: true,
+                undefined: true,
+                reduce: ts.factory.createLogicalAnd,
+                positive: ts.factory.createTrue(),
+                superfluous: (value) =>
+                    create_guard_call(importer)()(
+                        ts.factory.createAdd(
+                            ts.factory.createIdentifier("_path"),
+                            ts.factory.createCallExpression(
+                                importer.use("join"),
+                                undefined,
+                                [ts.factory.createIdentifier("key")],
+                            ),
                         ),
+                        "undefined",
+                        value,
                     ),
-                    "undefined",
-                    value,
-                ),
-            halt: (expr) =>
-                ts.factory.createLogicalOr(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createFalse(),
-                        ts.factory.createIdentifier("_exceptionable"),
+                halt: (expr) =>
+                    ts.factory.createLogicalOr(
+                        ts.factory.createStrictEquality(
+                            ts.factory.createFalse(),
+                            ts.factory.createIdentifier("_exceptionable"),
+                        ),
+                        expr,
                     ),
-                    expr,
-                ),
-        })(importer);
+            })(project)(importer);
 
     const joiner =
         (equals: boolean) =>
+        (project: IProject) =>
         (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
-            object: assert_object(equals)(importer),
+            object: assert_object(equals)(project)(importer),
             array: (input, arrow) =>
                 ts.factory.createCallExpression(
                     IdentifierFactory.access(input)("every"),

package/src/programmers/IsProgrammer.ts

@@ -21,6 +21,7 @@ import { feature_object_entries } from "./internal/feature_object_entries";
 export namespace IsProgrammer {
     export const configure =
         (options?: Partial<CONFIG.IOptions>) =>
+        (project: IProject) =>
         (importer: FunctionImporter): CheckerProgrammer.IConfig => ({
             prefix: "$i",
             equals: !!options?.object,
@@ -79,7 +80,7 @@ export namespace IsProgrammer {
                         reduce: ts.factory.createLogicalAnd,
                         positive: ts.factory.createTrue(),
                         superfluous: () => ts.factory.createFalse(),
-                    })(importer),
+                    })(project)(importer),
                 array: (input, arrow) =>
                     ts.factory.createCallExpression(
                         IdentifierFactory.access(input)("every"),
@@ -126,9 +127,9 @@ export namespace IsProgrammer {
                         reduce: ts.factory.createLogicalAnd,
                         positive: ts.factory.createTrue(),
                         superfluous: () => ts.factory.createFalse(),
-                    })(importer),
+                    })(project)(importer),
                     numeric: OptionPredicator.numeric(project.options),
-                })(importer),
+                })(project)(importer),
                 trace: equals,
                 addition: () => importer.declare(modulo),
             };
@@ -185,7 +186,7 @@ export namespace IsProgrammer {
         (project: IProject) =>
         (importer: FunctionImporter) =>
         (collection: MetadataCollection) => {
-            const config = configure()(importer);
+            const config = configure()(project)(importer);
             const objects =
                 CheckerProgrammer.write_object_functions(project)(config)(
                     importer,
@@ -223,10 +224,15 @@ export namespace IsProgrammer {
         DECODERS
     ----------------------------------------------------------- */
     export const decode = (project: IProject) => (importer: FunctionImporter) =>
-        CheckerProgrammer.decode(project)(configure()(importer))(importer);
+        CheckerProgrammer.decode(project)(configure()(project)(importer))(
+            importer,
+        );
 
-    export const decode_object = (importer: FunctionImporter) =>
-        CheckerProgrammer.decode_object(configure()(importer))(importer);
+    export const decode_object =
+        (project: IProject) => (importer: FunctionImporter) =>
+            CheckerProgrammer.decode_object(configure()(project)(importer))(
+                importer,
+            );
 
     export const decode_to_json =
         (checkNull: boolean) =>

package/src/programmers/ValidateProgrammer.ts

@@ -97,8 +97,8 @@ export namespace ValidateProgrammer {
                                       ),
                                   ]),
                         ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
-                    combiner: combine(equals)(importer),
-                    joiner: joiner(equals)(importer),
+                    combiner: combine(equals)(project)(importer),
+                    joiner: joiner(equals)(project)(importer),
                     success: ts.factory.createTrue(),
                     addition: () => importer.declare(modulo),
                 },
@@ -195,13 +195,14 @@ export namespace ValidateProgrammer {
 
 const combine =
     (equals: boolean) =>
+    (project: IProject) =>
     (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
     (explore: CheckerProgrammer.IExplore) => {
         if (explore.tracable === false)
             return IsProgrammer.configure({
-                object: validate_object(equals)(importer),
+                object: validate_object(equals)(project)(importer),
                 numeric: true,
-            })(importer).combiner(explore);
+            })(project)(importer).combiner(explore);
 
         const path: string = explore.postfix
             ? `_path + ${explore.postfix}`
@@ -240,40 +241,42 @@ const combine =
                   );
     };
 
-const validate_object = (equals: boolean) => (importer: FunctionImporter) =>
-    check_object({
-        equals,
-        undefined: true,
-        assert: false,
-        reduce: ts.factory.createLogicalAnd,
-        positive: ts.factory.createTrue(),
-        superfluous: (value) =>
-            create_report_call()(
-                ts.factory.createAdd(
-                    ts.factory.createIdentifier("_path"),
-                    ts.factory.createCallExpression(
-                        importer.use("join"),
-                        undefined,
-                        [ts.factory.createIdentifier("key")],
+const validate_object =
+    (equals: boolean) => (project: IProject) => (importer: FunctionImporter) =>
+        check_object({
+            equals,
+            undefined: true,
+            assert: false,
+            reduce: ts.factory.createLogicalAnd,
+            positive: ts.factory.createTrue(),
+            superfluous: (value) =>
+                create_report_call()(
+                    ts.factory.createAdd(
+                        ts.factory.createIdentifier("_path"),
+                        ts.factory.createCallExpression(
+                            importer.use("join"),
+                            undefined,
+                            [ts.factory.createIdentifier("key")],
+                        ),
                     ),
+                    "undefined",
+                    value,
                 ),
-                "undefined",
-                value,
-            ),
-        halt: (expr) =>
-            ts.factory.createLogicalOr(
-                ts.factory.createStrictEquality(
-                    ts.factory.createFalse(),
-                    ts.factory.createIdentifier("_exceptionable"),
+            halt: (expr) =>
+                ts.factory.createLogicalOr(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createFalse(),
+                        ts.factory.createIdentifier("_exceptionable"),
+                    ),
+                    expr,
                 ),
-                expr,
-            ),
-    })(importer);
+        })(project)(importer);
 
 const joiner =
     (equals: boolean) =>
+    (project: IProject) =>
     (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
-        object: validate_object(equals)(importer),
+        object: validate_object(equals)(project)(importer),
         array: (input, arrow) =>
             check_everything(
                 ts.factory.createCallExpression(

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

package/src/programmers/helpers/NotationJoiner.ts

@@ -1,146 +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],
-        );
-}
+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],
+        );
+}