typia 7.0.0-dev.20240930 → 7.0.0-dev.20241001

package/src/programmers/FeatureProgrammer.ts

@@ -411,9 +411,12 @@ export namespace FeatureProgrammer {
           undefined,
           props.config.objector.joiner({
             input: ts.factory.createIdentifier("input"),
-            entries: feature_object_entries(props.config)(props.importer)(
+            entries: feature_object_entries({
+              config: props.config,
+              importer: props.importer,
+              input: ts.factory.createIdentifier("input"),
               object,
-            )(ts.factory.createIdentifier("input")),
+            }),
             object,
           }),
         ),
@@ -434,13 +437,8 @@ export namespace FeatureProgrammer {
       ),
     );
 
-  const write_union = (props: {
-    config: IConfig;
-    objects: MetadataObject[];
-  }) => {
-    const explorer = UnionExplorer.object(props.config);
-    const input = ValueFactory.INPUT();
-    return ts.factory.createArrowFunction(
+  const write_union = (props: { config: IConfig; objects: MetadataObject[] }) =>
+    ts.factory.createArrowFunction(
       undefined,
       undefined,
       parameterDeclarations({
@@ -450,14 +448,18 @@ export namespace FeatureProgrammer {
       }),
       TypeFactory.keyword("any"),
       undefined,
-      explorer(input, props.objects, {
-        tracable: props.config.path || props.config.trace,
-        source: "function",
-        from: "object",
-        postfix: "",
+      UnionExplorer.object({
+        config: props.config,
+        objects: props.objects,
+        input: ValueFactory.INPUT(),
+        explore: {
+          tracable: props.config.path || props.config.trace,
+          source: "function",
+          from: "object",
+          postfix: "",
+        },
       }),
     );
-  };
 
   /* -----------------------------------------------------------
         DECODERS

package/src/programmers/IsProgrammer.ts

@@ -60,18 +60,25 @@ export namespace IsProgrammer {
         : initial;
     },
     joiner: {
-      object:
-        props.options?.object ||
-        check_object({
-          equals: !!props.options?.object,
-          undefined: OptionPredicator.undefined({
-            undefined: props.options?.undefined,
-          }),
-          assert: true,
-          reduce: ts.factory.createLogicalAnd,
-          positive: ts.factory.createTrue(),
-          superfluous: () => ts.factory.createFalse(),
-        })(props.context)(props.importer),
+      object: props.options?.object
+        ? (v) => props.options!.object!(v)
+        : (v) =>
+            check_object({
+              config: {
+                equals: !!props.options?.object,
+                undefined: OptionPredicator.undefined({
+                  undefined: props.options?.undefined,
+                }),
+                assert: true,
+                reduce: ts.factory.createLogicalAnd,
+                positive: ts.factory.createTrue(),
+                superfluous: () => ts.factory.createFalse(),
+              },
+              context: props.context,
+              importer: props.importer,
+              entries: v.entries,
+              input: v.input,
+            }),
       array: (props) =>
         ts.factory.createCallExpression(
           IdentifierFactory.access(props.input)("every"),
@@ -115,14 +122,21 @@ export namespace IsProgrammer {
     const config: CheckerProgrammer.IConfig = {
       ...configure({
         options: {
-          object: check_object({
-            equals: props.config.equals,
-            undefined: OptionPredicator.undefined(props.context.options),
-            assert: true,
-            reduce: ts.factory.createLogicalAnd,
-            positive: ts.factory.createTrue(),
-            superfluous: () => ts.factory.createFalse(),
-          })(props.context)(props.importer),
+          object: (v) =>
+            check_object({
+              config: {
+                equals: props.config.equals,
+                undefined: OptionPredicator.undefined(props.context.options),
+                assert: true,
+                reduce: ts.factory.createLogicalAnd,
+                positive: ts.factory.createTrue(),
+                superfluous: () => ts.factory.createFalse(),
+              },
+              context: props.context,
+              importer: props.importer,
+              entries: v.entries,
+              input: v.input,
+            }),
           numeric: OptionPredicator.numeric(props.context.options),
         },
         context: props.context,

package/src/programmers/RandomProgrammer.ts

@@ -481,8 +481,11 @@ export namespace RandomProgrammer {
           ? "uint"
           : "double";
       const multiply = tags.find((t) => t.kind === "multipleOf");
-      return random_custom(coalesce(props.importer))("number")(tags)(
-        RandomRanger.number({
+      return random_custom({
+        accessor: coalesce(props.importer),
+        type: "number",
+        tags,
+        expression: RandomRanger.number({
           config: {
             type,
             transform: (value) => ExpressionFactory.number(value),
@@ -502,7 +505,7 @@ export namespace RandomProgrammer {
           },
           tags,
         }),
-      );
+      });
     });
 
   const decode_bigint = (props: {
@@ -510,8 +513,11 @@ export namespace RandomProgrammer {
     atomic: MetadataAtomic;
   }): ts.Expression[] =>
     (props.atomic.tags.length ? props.atomic.tags : [[]]).map((tags) =>
-      random_custom(coalesce(props.importer))("bigint")(tags)(
-        RandomRanger.number({
+      random_custom({
+        accessor: coalesce(props.importer),
+        type: "bigint",
+        tags,
+        expression: RandomRanger.number({
           config: {
             type: tags.find(
               (t) =>
@@ -535,7 +541,7 @@ export namespace RandomProgrammer {
           },
           tags,
         }),
-      ),
+      }),
     );
 
   const decode_string = (props: {
@@ -543,8 +549,11 @@ export namespace RandomProgrammer {
     atomic: MetadataAtomic;
   }): ts.Expression[] =>
     (props.atomic.tags.length ? props.atomic.tags : [[]]).map((tags) =>
-      random_custom(coalesce(props.importer))("string")(tags)(
-        (() => {
+      random_custom({
+        accessor: coalesce(props.importer),
+        type: "string",
+        tags,
+        expression: (() => {
           for (const t of tags)
             if (t.kind === "format")
               return ts.factory.createCallExpression(
@@ -582,7 +591,7 @@ export namespace RandomProgrammer {
             tail ? [tail] : undefined,
           );
         })(),
-      ),
+      }),
     );
 
   const decode_array = (props: {

package/src/programmers/TypiaProgrammer.ts

@@ -7,47 +7,54 @@ import { ImportTransformer } from "../transformers/ImportTransformer";
 import transform from "../transform";
 
 export namespace TypiaProgrammer {
-  export interface IProps {
+  export interface ILocation {
     input: string;
     output: string;
     project: string;
   }
 
-  export const build = async (props: TypiaProgrammer.IProps): Promise<void> => {
-    props.input = path.resolve(props.input);
-    props.output = path.resolve(props.output);
+  export const build = async (
+    location: TypiaProgrammer.ILocation,
+  ): Promise<void> => {
+    location.input = path.resolve(location.input);
+    location.output = path.resolve(location.output);
 
-    if ((await is_directory(props.input)) === false)
+    if ((await is_directory(location.input)) === false)
       throw new URIError(
         "Error on TypiaGenerator.generate(): input path is not a directory.",
       );
-    else if (fs.existsSync(props.output) === false)
-      await fs.promises.mkdir(props.output, { recursive: true });
-    else if ((await is_directory(props.output)) === false) {
-      const parent: string = path.join(props.output, "..");
+    else if (fs.existsSync(location.output) === false)
+      await fs.promises.mkdir(location.output, { recursive: true });
+    else if ((await is_directory(location.output)) === false) {
+      const parent: string = path.join(location.output, "..");
       if ((await is_directory(parent)) === false)
         throw new URIError(
           "Error on TypiaGenerator.generate(): output path is not a directory.",
         );
-      await fs.promises.mkdir(props.output);
+      await fs.promises.mkdir(location.output);
     }
 
     // CREATE PROGRAM
     const { options: compilerOptions } = ts.parseJsonConfigFileContent(
-      ts.readConfigFile(props.project, ts.sys.readFile).config,
+      ts.readConfigFile(location.project, ts.sys.readFile).config,
       {
         fileExists: ts.sys.fileExists,
         readFile: ts.sys.readFile,
         readDirectory: ts.sys.readDirectory,
         useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
       },
-      path.dirname(props.project),
+      path.dirname(location.project),
     );
 
     const program: ts.Program = ts.createProgram(
       await (async () => {
         const container: string[] = [];
-        await gather(props)(container)(props.input)(props.output);
+        await gather({
+          location,
+          container,
+          from: location.input,
+          to: location.output,
+        });
         return container;
       })(),
       compilerOptions,
@@ -61,10 +68,10 @@ export namespace TypiaProgrammer {
         .filter(
           (file) =>
             !file.isDeclarationFile &&
-            path.resolve(file.fileName).indexOf(props.input) !== -1,
+            path.resolve(file.fileName).indexOf(location.input) !== -1,
         ),
       [
-        ImportTransformer.transform(props.input)(props.output),
+        ImportTransformer.transform(location.input)(location.output),
         transform(
           program,
           ((compilerOptions.plugins as any[]) ?? []).find(
@@ -117,7 +124,7 @@ export namespace TypiaProgrammer {
     for (const file of result.transformed) {
       const to: string = path
         .resolve(file.fileName)
-        .replace(props.input, props.output);
+        .replace(location.input, location.output);
 
       const content: string = printer.printFile(file);
       await fs.promises.writeFile(to, content, "utf8");
@@ -129,24 +136,31 @@ export namespace TypiaProgrammer {
     return stat.isDirectory();
   };
 
-  const gather =
-    (props: IProps) =>
-    (container: string[]) =>
-    (from: string) =>
-    async (to: string) => {
-      if (from === props.output) return;
-      else if (fs.existsSync(to) === false) await fs.promises.mkdir(to);
-
-      for (const file of await fs.promises.readdir(from)) {
-        const next: string = path.join(from, file);
-        const stat: fs.Stats = await fs.promises.stat(next);
-
-        if (stat.isDirectory()) {
-          await gather(props)(container)(next)(path.join(to, file));
-          continue;
-        } else if (is_supported_extension(file)) container.push(next);
-      }
-    };
+  const gather = async (props: {
+    location: ILocation;
+    container: string[];
+    from: string;
+    to: string;
+  }) => {
+    if (props.from === props.location.output) return;
+    else if (fs.existsSync(props.to) === false)
+      await fs.promises.mkdir(props.to);
+
+    for (const file of await fs.promises.readdir(props.from)) {
+      const next: string = path.join(props.from, file);
+      const stat: fs.Stats = await fs.promises.stat(next);
+
+      if (stat.isDirectory()) {
+        await gather({
+          location: props.location,
+          container: props.container,
+          from: next,
+          to: path.join(props.to, file),
+        });
+        continue;
+      } else if (is_supported_extension(file)) props.container.push(next);
+    }
+  };
 
   const is_supported_extension = (filename: string): boolean => {
     return (

package/src/programmers/ValidateProgrammer.ts

@@ -12,6 +12,7 @@ import { CheckerProgrammer } from "./CheckerProgrammer";
 import { FeatureProgrammer } from "./FeatureProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
 import { FunctionImporter } from "./helpers/FunctionImporter";
+import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_everything } from "./internal/check_everything";
 import { check_object } from "./internal/check_object";
@@ -252,7 +253,14 @@ const combine =
     if (next.explore.tracable === false)
       return IsProgrammer.configure({
         options: {
-          object: validate_object(props),
+          object: (v) =>
+            validate_object({
+              context: props.context,
+              importer: props.importer,
+              config: props.config,
+              entries: v.entries,
+              input: v.input,
+            }),
           numeric: true,
         },
         context: props.context,
@@ -301,42 +309,57 @@ const validate_object = (props: {
   config: ValidateProgrammer.IConfig;
   context: ITypiaContext;
   importer: FunctionImporter;
+  entries: IExpressionEntry<ts.Expression>[];
+  input: ts.Expression;
 }) =>
   check_object({
-    equals: props.config.equals,
-    undefined: true,
-    assert: false,
-    reduce: ts.factory.createLogicalAnd,
-    positive: ts.factory.createTrue(),
-    superfluous: (input) =>
-      create_report_call({
-        path: ts.factory.createAdd(
-          ts.factory.createIdentifier("_path"),
-          ts.factory.createCallExpression(
-            props.importer.use("join"),
-            undefined,
-            [ts.factory.createIdentifier("key")],
+    config: {
+      equals: props.config.equals,
+      undefined: true,
+      assert: false,
+      reduce: ts.factory.createLogicalAnd,
+      positive: ts.factory.createTrue(),
+      superfluous: (input) =>
+        create_report_call({
+          path: ts.factory.createAdd(
+            ts.factory.createIdentifier("_path"),
+            ts.factory.createCallExpression(
+              props.importer.use("join"),
+              undefined,
+              [ts.factory.createIdentifier("key")],
+            ),
           ),
+          expected: "undefined",
+          input,
+        }),
+      halt: (expr) =>
+        ts.factory.createLogicalOr(
+          ts.factory.createStrictEquality(
+            ts.factory.createFalse(),
+            ts.factory.createIdentifier("_exceptionable"),
+          ),
+          expr,
         ),
-        expected: "undefined",
-        input,
-      }),
-    halt: (expr) =>
-      ts.factory.createLogicalOr(
-        ts.factory.createStrictEquality(
-          ts.factory.createFalse(),
-          ts.factory.createIdentifier("_exceptionable"),
-        ),
-        expr,
-      ),
-  })(props.context)(props.importer);
+    },
+    context: props.context,
+    importer: props.importer,
+    entries: props.entries,
+    input: props.input,
+  });
 
 const joiner = (props: {
   config: ValidateProgrammer.IConfig;
   context: ITypiaContext;
   importer: FunctionImporter;
 }): CheckerProgrammer.IConfig.IJoiner => ({
-  object: validate_object(props),
+  object: (v) =>
+    validate_object({
+      context: props.context,
+      importer: props.importer,
+      config: props.config,
+      entries: v.entries,
+      input: v.input,
+    }),
   array: (props) =>
     check_everything(
       ts.factory.createCallExpression(

package/src/programmers/helpers/CloneJoiner.ts

@@ -68,7 +68,10 @@ export namespace CloneJoiner {
         ts.factory.createIfStatement(
           ts.factory.createCallExpression(
             ts.factory.createIdentifier(
-              `RegExp(/${metadata_to_pattern(true)(entry.key)}/).test`,
+              `RegExp(/${metadata_to_pattern({
+                top: true,
+                metadata: entry.key,
+              })}/).test`,
             ),
             undefined,
             [key],

package/src/programmers/helpers/NotationJoiner.ts

@@ -10,103 +10,105 @@ import { metadata_to_pattern } from "../internal/metadata_to_pattern";
 import { IExpressionEntry } from "./IExpressionEntry";
 
 export namespace NotationJoiner {
-  export const object =
-    (rename: (str: string) => string) =>
-    (props: {
-      input: ts.Expression;
-      entries: IExpressionEntry<ts.Expression>[];
-    }): ts.ConciseBody => {
-      if (props.entries.length === 0) return ts.factory.createIdentifier("{}");
+  export const object = (props: {
+    rename: (str: string) => string;
+    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 = 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 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 = props.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 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(),
-          ),
-        );
+    const statements: ts.Statement[] = [];
+    if (regular.length !== 0)
       statements.push(
-        ...dynamic.map((entry) =>
-          ts.factory.createIfStatement(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier(
-                `RegExp(/${metadata_to_pattern(true)(entry.key)}/).test`,
+        ts.factory.createIfStatement(
+          ts.factory.createCallExpression(
+            IdentifierFactory.access(
+              ts.factory.createArrayLiteralExpression(
+                regular.map((r) =>
+                  ts.factory.createStringLiteral(r.key.getSoleLiteral()!),
+                ),
               ),
-              undefined,
-              [key],
-            ),
-            ts.factory.createBlock([
-              ts.factory.createExpressionStatement(
-                ts.factory.createBinaryExpression(
-                  ts.factory.createElementAccessExpression(output, key),
-                  ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-                  entry.expression,
+            )("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(),
-            ]),
+            ],
           ),
+          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"),
+    statements.push(
+      ...dynamic.map((entry) =>
+        ts.factory.createIfStatement(
           ts.factory.createCallExpression(
-            ts.factory.createIdentifier("Object.entries"),
+            ts.factory.createIdentifier(
+              `RegExp(/${metadata_to_pattern({
+                top: true,
+                metadata: entry.key,
+              })}/).test`,
+            ),
             undefined,
-            [props.input],
+            [key],
           ),
-          ts.factory.createBlock(statements),
+          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(),
+          ]),
         ),
-        ts.factory.createReturnStatement(output),
-      ]);
-    };
+      ),
+    );
+
+    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,
+          [props.input],
+        ),
+        ts.factory.createBlock(statements),
+      ),
+      ts.factory.createReturnStatement(output),
+    ]);
+  };
 
   export const tuple = (props: {
     elements: ts.Expression[];

package/src/programmers/helpers/ProtobufUtil.ts

@@ -39,7 +39,7 @@ export namespace ProtobufUtil {
     return [...set].sort(compare);
   };
 
-  export const getNumbers = (meta: Metadata) => {
+  export const getNumbers = (meta: Metadata): ProtobufAtomic.Numeric[] => {
     const set: Set<ProtobufAtomic.Numeric> = new Set();
     for (const c of meta.constants)
       if (c.type === "number")
@@ -50,7 +50,7 @@ export namespace ProtobufUtil {
     return [...set].sort(compare);
   };
 
-  export const getBigints = (meta: Metadata) => {
+  export const getBigints = (meta: Metadata): ProtobufAtomic.BigNumeric[] => {
     const set: Set<ProtobufAtomic.BigNumeric> = new Set();
     for (const c of meta.constants) if (c.type === "bigint") set.add("uint64");
     for (const atomic of meta.atomics)

package/src/programmers/helpers/PruneJoiner.ts

@@ -124,7 +124,10 @@ const iterate_dynamic_properties = (props: {
               ts.factory.createIfStatement(
                 ts.factory.createCallExpression(
                   ts.factory.createIdentifier(
-                    `RegExp(/${metadata_to_pattern(true)(dynamic.key)}/).test`,
+                    `RegExp(/${metadata_to_pattern({
+                      top: true,
+                      metadata: dynamic.key,
+                    })}/).test`,
                   ),
                   undefined,
                   [ts.factory.createIdentifier("key")],