typia 7.0.0-dev.20240930 → 7.0.0-dev.20241002

package/src/programmers/FeatureProgrammer.ts

@@ -397,9 +397,9 @@ export namespace FeatureProgrammer {
     collection: MetadataCollection;
   }) =>
     props.collection.objects().map((object) =>
-      StatementFactory.constant(
-        `${props.config.prefix}o${object.index}`,
-        ts.factory.createArrowFunction(
+      StatementFactory.constant({
+        name: `${props.config.prefix}o${object.index}`,
+        value: ts.factory.createArrowFunction(
           undefined,
           undefined,
           parameterDeclarations({
@@ -411,13 +411,16 @@ 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,
           }),
         ),
-      ),
+      }),
     );
 
   export const write_union_functions = (props: {
@@ -425,22 +428,17 @@ export namespace FeatureProgrammer {
     collection: MetadataCollection;
   }) =>
     props.collection.unions().map((union, i) =>
-      StatementFactory.constant(
-        `${props.config.prefix}u${i}`,
-        write_union({
+      StatementFactory.constant({
+        name: `${props.config.prefix}u${i}`,
+        value: write_union({
           config: props.config,
           objects: union,
         }),
-      ),
+      }),
     );
 
-  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,21 +60,28 @@ 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"),
+          IdentifierFactory.access(props.input, "every"),
           undefined,
           [props.arrow],
         ),
@@ -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,
@@ -245,10 +259,11 @@ export namespace IsProgrammer {
       ExpressionFactory.isObject({
         checkArray: false,
         checkNull: props.checkNull,
-      })(props.input),
+        input: props.input,
+      }),
       ts.factory.createStrictEquality(
         ts.factory.createStringLiteral("function"),
-        ValueFactory.TYPEOF(IdentifierFactory.access(props.input)("toJSON")),
+        ValueFactory.TYPEOF(IdentifierFactory.access(props.input, "toJSON")),
       ),
     );
 

package/src/programmers/RandomProgrammer.ts

@@ -107,7 +107,10 @@ export namespace RandomProgrammer {
         [
           ts.factory.createTypeReferenceNode(
             props.name ??
-              TypeFactory.getFullName(props.context.checker)(props.type),
+              TypeFactory.getFullName({
+                checker: props.context.checker,
+                type: props.type,
+              }),
           ),
         ],
         false,
@@ -138,7 +141,7 @@ export namespace RandomProgrammer {
     );
     return {
       functions,
-      statements: [StatementFactory.mut("_generator")],
+      statements: [StatementFactory.mut({ name: "_generator" })],
       arrow,
     };
   };
@@ -163,9 +166,9 @@ export namespace RandomProgrammer {
     collection: MetadataCollection;
   }): ts.VariableStatement[] =>
     props.collection.objects().map((obj, i) =>
-      StatementFactory.constant(
-        Prefix.object(i),
-        ts.factory.createArrowFunction(
+      StatementFactory.constant({
+        name: Prefix.object(i),
+        value: ts.factory.createArrowFunction(
           undefined,
           undefined,
           [
@@ -196,7 +199,7 @@ export namespace RandomProgrammer {
             object: obj,
           }),
         ),
-      ),
+      }),
     );
 
   const write_array_functions = (props: {
@@ -207,9 +210,9 @@ export namespace RandomProgrammer {
       .arrays()
       .filter((a) => a.recursive)
       .map((array, i) =>
-        StatementFactory.constant(
-          Prefix.array(i),
-          ts.factory.createArrowFunction(
+        StatementFactory.constant({
+          name: Prefix.array(i),
+          value: ts.factory.createArrowFunction(
             undefined,
             undefined,
             [
@@ -254,7 +257,7 @@ export namespace RandomProgrammer {
               metadata: array.value,
             }),
           ),
-        ),
+        }),
       );
 
   const write_tuple_functions = (props: {
@@ -265,9 +268,9 @@ export namespace RandomProgrammer {
       .tuples()
       .filter((a) => a.recursive)
       .map((tuple, i) =>
-        StatementFactory.constant(
-          Prefix.tuple(i),
-          ts.factory.createArrowFunction(
+        StatementFactory.constant({
+          name: Prefix.tuple(i),
+          value: ts.factory.createArrowFunction(
             undefined,
             undefined,
             [
@@ -297,7 +300,7 @@ export namespace RandomProgrammer {
               elements: tuple.elements,
             }),
           ),
-        ),
+        }),
       );
 
   /* -----------------------------------------------------------
@@ -481,8 +484,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 +508,7 @@ export namespace RandomProgrammer {
           },
           tags,
         }),
-      );
+      });
     });
 
   const decode_bigint = (props: {
@@ -510,8 +516,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 +544,7 @@ export namespace RandomProgrammer {
           },
           tags,
         }),
-      ),
+      }),
     );
 
   const decode_string = (props: {
@@ -543,8 +552,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 +594,7 @@ export namespace RandomProgrammer {
             tail ? [tail] : undefined,
           );
         })(),
-      ),
+      }),
     );
 
   const decode_array = (props: {
@@ -996,39 +1008,41 @@ export namespace RandomProgrammer {
             importer: props.importer,
             name: "Uint8Array",
           }),
-        )("buffer")
+          "buffer",
+        )
       : ExpressionFactory.selfCall(
           ts.factory.createBlock(
             [
-              StatementFactory.constant(
-                "length",
-                ts.factory.createCallExpression(
+              StatementFactory.constant({
+                name: "length",
+                value: ts.factory.createCallExpression(
                   coalesce(props.importer)("integer"),
                   undefined,
                   [],
                 ),
-              ),
-              StatementFactory.constant(
-                "buffer",
-                ts.factory.createNewExpression(
+              }),
+              StatementFactory.constant({
+                name: "buffer",
+                value: ts.factory.createNewExpression(
                   ts.factory.createIdentifier("SharedArrayBuffer"),
                   [],
                   [ts.factory.createIdentifier("length")],
                 ),
-              ),
-              StatementFactory.constant(
-                "bytes",
-                ts.factory.createNewExpression(
+              }),
+              StatementFactory.constant({
+                name: "bytes",
+                value: ts.factory.createNewExpression(
                   ts.factory.createIdentifier("Uint8Array"),
                   [],
                   [ts.factory.createIdentifier("buffer")],
                 ),
-              ),
+              }),
               ts.factory.createExpressionStatement(
                 ts.factory.createCallExpression(
                   IdentifierFactory.access(
                     ts.factory.createIdentifier("bytes"),
-                  )("set"),
+                    "set",
+                  ),
                   undefined,
                   [
                     ts.factory.createCallExpression(
@@ -1075,7 +1089,8 @@ export namespace RandomProgrammer {
             importer,
             name: "Uint8Array",
           }),
-        )("buffer"),
+          "buffer",
+        ),
       ],
     );
 
@@ -1112,7 +1127,8 @@ const coalesce = (importer: FunctionImporter) => (name: string) =>
           ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
           ts.factory.createStringLiteral(name),
         ),
-  )(IdentifierFactory.access(importer.use("generator"))(name));
+    IdentifierFactory.access(importer.use("generator"), name),
+  );
 
 const emendFormat = (key: keyof Format.Validator) =>
   key === "date-time"

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 (