typia 7.0.0-dev.20241003 → 7.0.0-dev.20241005

package/src/programmers/ValidateProgrammer.ts

@@ -11,7 +11,7 @@ import { ITypiaContext } from "../transformers/ITypiaContext";
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { FeatureProgrammer } from "./FeatureProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
-import { FunctionImporter } from "./helpers/FunctionImporter";
+import { FunctionProgrammer } from "./helpers/FunctionProgrammer";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_everything } from "./internal/check_everything";
@@ -28,7 +28,7 @@ export namespace ValidateProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     config: IConfig;
     type: ts.Type;
     name: string | undefined;
@@ -138,14 +138,9 @@ export namespace ValidateProgrammer {
                   ts.factory.createIdentifier("$report"),
                   ts.factory.createToken(ts.SyntaxKind.EqualsToken),
                   ts.factory.createCallExpression(
-                    IdentifierFactory.access(
-                      ts.factory.createParenthesizedExpression(
-                        ts.factory.createAsExpression(
-                          props.modulo,
-                          TypeFactory.keyword("any"),
-                        ),
-                      ),
-                      "report",
+                    ts.factory.createAsExpression(
+                      props.context.importer.internal("$validateReport"),
+                      TypeFactory.keyword("any"),
                     ),
                     [],
                     [ts.factory.createIdentifier("errors")],
@@ -231,20 +226,20 @@ export namespace ValidateProgrammer {
   };
 
   export const write = (props: IProps) => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       config: props.config,
       context: props.context,
       modulo: props.modulo,
-      importer,
+      functor,
       type: props.type,
       name: props.name,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };
@@ -254,7 +249,7 @@ const combine =
   (props: {
     config: ValidateProgrammer.IConfig;
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
   }): CheckerProgrammer.IConfig.Combiner =>
   (next) => {
     if (next.explore.tracable === false)
@@ -263,7 +258,7 @@ const combine =
           object: (v) =>
             validate_object({
               context: props.context,
-              importer: props.importer,
+              functor: props.functor,
               config: props.config,
               entries: v.entries,
               input: v.input,
@@ -271,7 +266,7 @@ const combine =
           numeric: true,
         },
         context: props.context,
-        importer: props.importer,
+        functor: props.functor,
       }).combiner(next);
 
     const path: string = next.explore.postfix
@@ -315,7 +310,7 @@ const combine =
 const validate_object = (props: {
   config: ValidateProgrammer.IConfig;
   context: ITypiaContext;
-  importer: FunctionImporter;
+  functor: FunctionProgrammer;
   entries: IExpressionEntry<ts.Expression>[];
   input: ts.Expression;
 }) =>
@@ -331,7 +326,7 @@ const validate_object = (props: {
           path: ts.factory.createAdd(
             ts.factory.createIdentifier("_path"),
             ts.factory.createCallExpression(
-              props.importer.use("join"),
+              props.context.importer.internal("accessExpressionAsString"),
               undefined,
               [ts.factory.createIdentifier("key")],
             ),
@@ -349,7 +344,6 @@ const validate_object = (props: {
         ),
     },
     context: props.context,
-    importer: props.importer,
     entries: props.entries,
     input: props.input,
   });
@@ -357,12 +351,12 @@ const validate_object = (props: {
 const joiner = (props: {
   config: ValidateProgrammer.IConfig;
   context: ITypiaContext;
-  importer: FunctionImporter;
+  functor: FunctionProgrammer;
 }): CheckerProgrammer.IConfig.IJoiner => ({
   object: (v) =>
     validate_object({
       context: props.context,
-      importer: props.importer,
+      functor: props.functor,
       config: props.config,
       entries: v.entries,
       input: v.input,

package/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts

@@ -2,7 +2,6 @@ import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
 
 import { ITypiaContext } from "../../transformers/ITypiaContext";
 
@@ -27,7 +26,7 @@ export namespace FunctionalAssertFunctionProgrammer {
 
   export const write = (props: IProps): ts.CallExpression => {
     const wrapper = errorFactoryWrapper({
-      modulo: props.modulo,
+      context: props.context,
       parameters: props.declaration.parameters,
       init: props.init,
     });
@@ -74,7 +73,7 @@ export namespace FunctionalAssertFunctionProgrammer {
   };
 
   export const errorFactoryWrapper = (props: {
-    modulo: ts.LeftHandSideExpression;
+    context: ITypiaContext;
     parameters: readonly ts.ParameterDeclaration[];
     init: ts.Expression | undefined;
   }): {
@@ -94,12 +93,8 @@ export namespace FunctionalAssertFunctionProgrammer {
             undefined,
             AssertProgrammer.Guardian.type(),
             props.init ??
-              ts.factory.createPropertyAccessExpression(
-                ts.factory.createAsExpression(
-                  props.modulo,
-                  TypeFactory.keyword("any"),
-                ),
-                "errorFactory",
+              props.context.importer.internal(
+                "functionalTypeGuardErrorFactory",
               ),
           ),
         ],

package/src/programmers/functional/FunctionalAssertParametersProgrammer.ts

@@ -36,7 +36,7 @@ export namespace FunctionalAssertParametersProgrammer {
 
   export const write = (props: IProps): ts.CallExpression => {
     const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper({
-      modulo: props.modulo,
+      context: props.context,
       parameters: props.declaration.parameters,
       init: props.init,
     });

package/src/programmers/functional/FunctionalAssertReturnProgrammer.ts

@@ -37,7 +37,7 @@ export namespace FunctionAssertReturnProgrammer {
 
   export const write = (props: IProps): ts.CallExpression => {
     const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper({
-      modulo: props.modulo,
+      context: props.context,
       parameters: props.declaration.parameters,
       init: props.init,
     });

package/src/programmers/helpers/AtomicPredicator.ts

@@ -1,35 +1,35 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { Atomic } from "../../typings/Atomic";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
-export namespace AtomicPredicator {
-  export const constant = (props: {
-    metadata: Metadata;
-    name: Atomic.Literal;
-  }): boolean =>
-    !ArrayUtil.has(
-      props.metadata.natives,
-      (native) => native.toLowerCase() === props.name,
-    );
-
-  export const atomic = (props: {
-    metadata: Metadata;
-    name: Atomic.Literal;
-  }): boolean =>
-    !ArrayUtil.has(
-      props.metadata.natives,
-      (native) => native.toLowerCase() === props.name,
-    );
-
-  export const native = (name: string) => LIKE.has(name.toLowerCase());
-
-  export const template = (metadata: Metadata): boolean =>
-    !ArrayUtil.has(
-      metadata.natives,
-      (native) => native.toLowerCase() === "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 = (props: {
+    metadata: Metadata;
+    name: Atomic.Literal;
+  }): boolean =>
+    !ArrayUtil.has(
+      props.metadata.natives,
+      (native) => native.toLowerCase() === props.name,
+    );
+
+  export const atomic = (props: {
+    metadata: Metadata;
+    name: Atomic.Literal;
+  }): boolean =>
+    !ArrayUtil.has(
+      props.metadata.natives,
+      (native) => native.toLowerCase() === props.name,
+    );
+
+  export const native = (name: string) => LIKE.has(name.toLowerCase());
+
+  export const template = (metadata: Metadata): boolean =>
+    !ArrayUtil.has(
+      metadata.natives,
+      (native) => native.toLowerCase() === "string",
+    );
+}
+
+const LIKE = new Set(["boolean", "bigint", "number", "string"]);

package/src/programmers/helpers/CloneJoiner.ts

@@ -1,143 +1,143 @@
-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 CloneJoiner {
-  export const object = (props: {
-    input: ts.Expression;
-    entries: IExpressionEntry<ts.Expression>[];
-  }): ts.ConciseBody => {
-    if (props.entries.length === 0) return ts.factory.createIdentifier("{}");
-
-    const regular = props.entries.filter((e) => e.key.isSoleLiteral());
-    const dynamic = props.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[] = [];
-    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({
-                top: true,
-                metadata: 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({
-        name: "output",
-        value: ts.factory.createAsExpression(
-          literal,
-          TypeFactory.keyword("any"),
-        ),
-      }),
-      ts.factory.createForOfStatement(
-        undefined,
-        StatementFactory.entry({
-          key: "key",
-          value: "value",
-        }),
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("Object.entries"),
-          undefined,
-          [props.input],
-        ),
-        ts.factory.createBlock(statements),
-      ),
-      ts.factory.createReturnStatement(output),
-    ]);
-  };
-
-  export const tuple = (props: {
-    elements: ts.Expression[];
-    rest: ts.Expression | null;
-  }): ts.Expression => {
-    return ts.factory.createAsExpression(
-      ts.factory.createArrayLiteralExpression(
-        props.rest === null
-          ? props.elements
-          : [...props.elements, ts.factory.createSpreadElement(props.rest)],
-        true,
-      ),
-      TypeFactory.keyword("any"),
-    );
-  };
-
-  export const array = (props: {
-    input: ts.Expression;
-    arrow: ts.Expression;
-  }) =>
-    ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(props.input, "map"),
-      undefined,
-      [props.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 CloneJoiner {
+  export const object = (props: {
+    input: ts.Expression;
+    entries: IExpressionEntry<ts.Expression>[];
+  }): ts.ConciseBody => {
+    if (props.entries.length === 0) return ts.factory.createIdentifier("{}");
+
+    const regular = props.entries.filter((e) => e.key.isSoleLiteral());
+    const dynamic = props.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[] = [];
+    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({
+                top: true,
+                metadata: 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({
+        name: "output",
+        value: ts.factory.createAsExpression(
+          literal,
+          TypeFactory.keyword("any"),
+        ),
+      }),
+      ts.factory.createForOfStatement(
+        undefined,
+        StatementFactory.entry({
+          key: "key",
+          value: "value",
+        }),
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("Object.entries"),
+          undefined,
+          [props.input],
+        ),
+        ts.factory.createBlock(statements),
+      ),
+      ts.factory.createReturnStatement(output),
+    ]);
+  };
+
+  export const tuple = (props: {
+    elements: ts.Expression[];
+    rest: ts.Expression | null;
+  }): ts.Expression => {
+    return ts.factory.createAsExpression(
+      ts.factory.createArrayLiteralExpression(
+        props.rest === null
+          ? props.elements
+          : [...props.elements, ts.factory.createSpreadElement(props.rest)],
+        true,
+      ),
+      TypeFactory.keyword("any"),
+    );
+  };
+
+  export const array = (props: {
+    input: ts.Expression;
+    arrow: ts.Expression;
+  }) =>
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(props.input, "map"),
+      undefined,
+      [props.arrow],
+    );
+}

package/src/programmers/helpers/{FunctionImporter.ts → FunctionProgrammer.ts}

@@ -4,7 +4,7 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-export class FunctionImporter {
+export class FunctionProgrammer {
   private readonly used_: Set<string> = new Set();
   private readonly local_: Set<string> = new Set();
   private readonly unions_: Map<string, [string, ts.ArrowFunction]> = new Map();
@@ -17,6 +17,9 @@ export class FunctionImporter {
     return this.used_.size === 0;
   }
 
+  /**
+   * @deprecated
+   */
   public use(name: string): ts.Identifier {
     this.used_.add(name);
     return ts.factory.createIdentifier("$" + name);

package/src/programmers/helpers/HttpMetadataUtil.ts

@@ -1,21 +1,21 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-export namespace HttpMetadataUtil {
-  export const atomics = (
-    metadata: Metadata,
-  ): Set<"boolean" | "bigint" | "number" | "string"> =>
-    new Set([
-      ...metadata.atomics.map((a) => a.type),
-      ...metadata.constants.map((c) => c.type),
-      ...(metadata.templates.length ? (["string"] as const) : []),
-    ]);
-
-  export const isUnion = (metadata: Metadata): boolean =>
-    atomics(metadata).size +
-      metadata.arrays.length +
-      metadata.tuples.length +
-      metadata.natives.length +
-      metadata.maps.length +
-      metadata.objects.length >
-    1;
-}
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+export namespace HttpMetadataUtil {
+  export const atomics = (
+    metadata: Metadata,
+  ): Set<"boolean" | "bigint" | "number" | "string"> =>
+    new Set([
+      ...metadata.atomics.map((a) => a.type),
+      ...metadata.constants.map((c) => c.type),
+      ...(metadata.templates.length ? (["string"] as const) : []),
+    ]);
+
+  export const isUnion = (metadata: Metadata): boolean =>
+    atomics(metadata).size +
+      metadata.arrays.length +
+      metadata.tuples.length +
+      metadata.natives.length +
+      metadata.maps.length +
+      metadata.objects.length >
+    1;
+}