typia 7.0.0-dev.20240929 → 7.0.0-dev.20241001

package/src/programmers/IsProgrammer.ts

@@ -19,68 +19,76 @@ import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_object } from "./internal/check_object";
 
 export namespace IsProgrammer {
-  export const configure =
-    (options?: Partial<CONFIG.IOptions>) =>
-    (project: ITypiaContext) =>
-    (importer: FunctionImporter): CheckerProgrammer.IConfig => ({
-      prefix: "$i",
-      equals: !!options?.object,
-      trace: false,
-      path: false,
-      numeric: OptionPredicator.numeric({
-        numeric: options?.numeric,
-      }),
-      atomist: ({ entry }) =>
-        [
-          ...(entry.expression ? [entry.expression] : []),
-          ...(entry.conditions.length === 0
-            ? []
-            : [
-                entry.conditions
-                  .map((set) =>
-                    set
-                      .map((s) => s.expression)
-                      .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
-                  )
-                  .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-              ]),
-        ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
-      combiner: (next) => {
-        const initial: ts.TrueLiteral | ts.FalseLiteral =
-          next.logic === "and"
-            ? ts.factory.createTrue()
-            : ts.factory.createFalse();
-        const binder =
-          next.logic === "and"
-            ? ts.factory.createLogicalAnd
-            : ts.factory.createLogicalOr;
-        return next.binaries.length
-          ? next.binaries.map((binary) => binary.expression).reduce(binder)
-          : initial;
-      },
-      joiner: {
-        object:
-          options?.object ||
-          check_object({
-            equals: !!options?.object,
-            undefined: OptionPredicator.undefined({
-              undefined: options?.undefined,
+  export const configure = (props: {
+    options?: Partial<CONFIG.IOptions>;
+    context: ITypiaContext;
+    importer: FunctionImporter;
+  }): CheckerProgrammer.IConfig => ({
+    prefix: "$i",
+    equals: !!props.options?.object,
+    trace: false,
+    path: false,
+    numeric: OptionPredicator.numeric({
+      numeric: props.options?.numeric,
+    }),
+    atomist: ({ entry }) =>
+      [
+        ...(entry.expression ? [entry.expression] : []),
+        ...(entry.conditions.length === 0
+          ? []
+          : [
+              entry.conditions
+                .map((set) =>
+                  set
+                    .map((s) => s.expression)
+                    .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
+                )
+                .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+            ]),
+      ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
+    combiner: (next) => {
+      const initial: ts.TrueLiteral | ts.FalseLiteral =
+        next.logic === "and"
+          ? ts.factory.createTrue()
+          : ts.factory.createFalse();
+      const binder =
+        next.logic === "and"
+          ? ts.factory.createLogicalAnd
+          : ts.factory.createLogicalOr;
+      return next.binaries.length
+        ? next.binaries.map((binary) => binary.expression).reduce(binder)
+        : initial;
+    },
+    joiner: {
+      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,
             }),
-            assert: true,
-            reduce: ts.factory.createLogicalAnd,
-            positive: ts.factory.createTrue(),
-            superfluous: () => ts.factory.createFalse(),
-          })(project)(importer),
-        array: (props) =>
-          ts.factory.createCallExpression(
-            IdentifierFactory.access(props.input)("every"),
-            undefined,
-            [props.arrow],
-          ),
-        failure: () => ts.factory.createFalse(),
-      },
-      success: ts.factory.createTrue(),
-    });
+      array: (props) =>
+        ts.factory.createCallExpression(
+          IdentifierFactory.access(props.input)("every"),
+          undefined,
+          [props.arrow],
+        ),
+      failure: () => ts.factory.createFalse(),
+    },
+    success: ts.factory.createTrue(),
+  });
 
   export namespace CONFIG {
     export interface IOptions {
@@ -113,16 +121,27 @@ export namespace IsProgrammer {
     // CONFIGURATION
     const config: CheckerProgrammer.IConfig = {
       ...configure({
-        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),
-        numeric: OptionPredicator.numeric(props.context.options),
-      })(props.context)(props.importer),
+        options: {
+          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,
+        importer: props.importer,
+      }),
       trace: props.config.equals,
     };
 
@@ -168,9 +187,7 @@ export namespace IsProgrammer {
     importer: FunctionImporter;
     collection: MetadataCollection;
   }) => {
-    const config: CheckerProgrammer.IConfig = configure()(props.context)(
-      props.importer,
-    );
+    const config: CheckerProgrammer.IConfig = configure(props);
     const next = {
       ...props,
       config,
@@ -212,7 +229,7 @@ export namespace IsProgrammer {
   }) =>
     CheckerProgrammer.decode({
       context: props.context,
-      config: configure()(props.context)(props.importer),
+      config: configure(props),
       importer: props.importer,
       metadata: props.metadata,
       input: props.input,
@@ -227,7 +244,7 @@ export namespace IsProgrammer {
     explore: FeatureProgrammer.IExplore;
   }) =>
     CheckerProgrammer.decode_object({
-      config: configure()(props.context)(props.importer),
+      config: configure(props),
       importer: props.importer,
       object: props.object,
       input: props.input,

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";
@@ -251,9 +252,20 @@ const combine =
   (next) => {
     if (next.explore.tracable === false)
       return IsProgrammer.configure({
-        object: validate_object(props),
-        numeric: true,
-      })(props.context)(props.importer).combiner(next);
+        options: {
+          object: (v) =>
+            validate_object({
+              context: props.context,
+              importer: props.importer,
+              config: props.config,
+              entries: v.entries,
+              input: v.input,
+            }),
+          numeric: true,
+        },
+        context: props.context,
+        importer: props.importer,
+      }).combiner(next);
 
     const path: string = next.explore.postfix
       ? `_path + ${next.explore.postfix}`
@@ -297,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],