typia 6.10.1-dev.20240914 → 7.0.0-dev.20240918

package/src/programmers/TypiaProgrammer.ts

@@ -1,157 +1,157 @@
-import fs from "fs";
-import path from "path";
-import ts from "typescript";
-
-import { ImportTransformer } from "../transformers/ImportTransformer";
-
-import { SourceFinder } from "../executable/setup/SourceFinder";
-import transform from "../transform";
-
-export namespace TypiaProgrammer {
-  export interface IProps {
-    input: string;
-    output: string;
-    project: string;
-  }
-
-  export const build = async (props: TypiaProgrammer.IProps): Promise<void> => {
-    const files: string[] = await SourceFinder.find({
-      include: [props.input],
-      filter: (location: string) =>
-        (location.endsWith(".ts") && !location.endsWith("d.ts")) ||
-        (location.endsWith(".tsx") && !location.endsWith("d.tsx")),
-    });
-    if (files.length === 0)
-      throw new Error(
-        "Error on TypiaGenerator.generate(): no file to generate.",
-      );
-    else if (fs.existsSync(props.output) === false)
-      await fs.promises.mkdir(props.output, { recursive: true });
-    else if ((await isDirectory(props.output)) === false) {
-      const parent: string = path.join(props.output, "..");
-      if ((await isDirectory(parent)) === false)
-        throw new Error(
-          "Error on TypiaGenerator.generate(): output path is not a directory.",
-        );
-      await fs.promises.mkdir(props.output);
-    }
-
-    // CREATE PROGRAM
-    const base: string = (await isDirectory(props.input))
-      ? path.resolve(props.input)
-      : getBaseDirectory(files);
-    const { options: compilerOptions } = ts.parseJsonConfigFileContent(
-      ts.readConfigFile(props.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),
-    );
-    const program: ts.Program = ts.createProgram(files, compilerOptions);
-
-    // DO TRANSFORM
-    const diagnostics: ts.Diagnostic[] = [];
-    const result: ts.TransformationResult<ts.SourceFile> = ts.transform(
-      program
-        .getSourceFiles()
-        .filter(
-          (file) =>
-            !file.isDeclarationFile &&
-            path.resolve(file.fileName).indexOf(base) !== -1,
-        ),
-      [
-        ImportTransformer.transform(base)(props.output),
-        transform(
-          program,
-          ((compilerOptions.plugins as any[]) ?? []).find(
-            (p: any) =>
-              p.transform === "typia/lib/transform" ||
-              p.transform === "../src/transform.ts",
-          ) ?? {},
-          {
-            addDiagnostic: (diag) => diagnostics.push(diag),
-          },
-        ),
-      ],
-      program.getCompilerOptions(),
-    );
-
-    // TRACE ERRORS
-    for (const diag of diagnostics) {
-      const file: string = diag.file
-        ? path.relative(diag.file.fileName, process.cwd())
-        : "(unknown file)";
-      const category: string =
-        diag.category === ts.DiagnosticCategory.Warning
-          ? "warning"
-          : diag.category === ts.DiagnosticCategory.Error
-            ? "error"
-            : diag.category === ts.DiagnosticCategory.Suggestion
-              ? "suggestion"
-              : diag.category === ts.DiagnosticCategory.Message
-                ? "message"
-                : "unkown";
-      const [line, pos] = diag.file
-        ? (() => {
-            const lines: string[] = diag
-              .file!.text.substring(0, diag.start)
-              .split("\n");
-            if (lines.length === 0) return [0, 0];
-            return [lines.length, lines.at(-1)!.length + 1];
-          })()
-        : [0, 0];
-      console.error(
-        `${file}:${line}:${pos} - ${category} TS${diag.code}: ${diag.messageText}`,
-      );
-    }
-    if (diagnostics.length) process.exit(-1);
-
-    // ARCHIVE TRANSFORMED FILES
-    const directories: Set<string> = new Set();
-    const printer: ts.Printer = ts.createPrinter({
-      newLine: ts.NewLineKind.LineFeed,
-    });
-    for (const file of result.transformed) {
-      const to: string = path
-        .resolve(file.fileName)
-        .replace(base, props.output);
-      const content: string = printer.printFile(file);
-
-      const parents: string[] = to.split(path.sep);
-      for (let i = 1; i < parents.length; i++) {
-        const parent: string = parents.slice(0, i).join(path.sep);
-        if (directories.has(parent)) continue;
-        try {
-          await fs.promises.mkdir(parent);
-        } catch {}
-      }
-      await fs.promises.writeFile(to, content, "utf8");
-    }
-  };
-
-  const isDirectory = async (current: string): Promise<boolean> => {
-    try {
-      const stat: fs.Stats = await fs.promises.stat(current);
-      return stat.isDirectory();
-    } catch {
-      return false;
-    }
-  };
-
-  const getBaseDirectory = (files: string[]): string => {
-    const splitPaths: string[][] = files.map((p) => p.split(path.sep));
-    const minLength: number = Math.min(...splitPaths.map((p) => p.length));
-    let commonPath: string[] = [];
-
-    for (let i = 0; i < minLength; i++) {
-      const currentSegment: string = splitPaths[0]![i]!;
-      if (splitPaths.every((p) => p[i] === currentSegment))
-        commonPath.push(currentSegment);
-      else break;
-    }
-    return commonPath.length > 0 ? commonPath.join(path.sep) : "";
-  };
-}
+import fs from "fs";
+import path from "path";
+import ts from "typescript";
+
+import { ImportTransformer } from "../transformers/ImportTransformer";
+
+import transform from "../transform";
+
+export namespace TypiaProgrammer {
+  export interface IProps {
+    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);
+
+    if ((await is_directory(props.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, "..");
+      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);
+    }
+
+    // CREATE PROGRAM
+    const { options: compilerOptions } = ts.parseJsonConfigFileContent(
+      ts.readConfigFile(props.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),
+    );
+
+    const program: ts.Program = ts.createProgram(
+      await (async () => {
+        const container: string[] = [];
+        await gather(props)(container)(props.input)(props.output);
+        return container;
+      })(),
+      compilerOptions,
+    );
+
+    // DO TRANSFORM
+    const diagnostics: ts.Diagnostic[] = [];
+    const result: ts.TransformationResult<ts.SourceFile> = ts.transform(
+      program
+        .getSourceFiles()
+        .filter(
+          (file) =>
+            !file.isDeclarationFile &&
+            path.resolve(file.fileName).indexOf(props.input) !== -1,
+        ),
+      [
+        ImportTransformer.transform(props.input)(props.output),
+        transform(
+          program,
+          ((compilerOptions.plugins as any[]) ?? []).find(
+            (p: any) =>
+              p.transform === "typia/lib/transform" ||
+              p.transform === "../src/transform.ts",
+          ) ?? {},
+          {
+            addDiagnostic: (diag) => diagnostics.push(diag),
+          },
+        ),
+      ],
+      program.getCompilerOptions(),
+    );
+
+    // TRACE ERRORS
+    for (const diag of diagnostics) {
+      const file: string = diag.file
+        ? path.relative(diag.file.fileName, process.cwd())
+        : "(unknown file)";
+      const category: string =
+        diag.category === ts.DiagnosticCategory.Warning
+          ? "warning"
+          : diag.category === ts.DiagnosticCategory.Error
+            ? "error"
+            : diag.category === ts.DiagnosticCategory.Suggestion
+              ? "suggestion"
+              : diag.category === ts.DiagnosticCategory.Message
+                ? "message"
+                : "unkown";
+      const [line, pos] = diag.file
+        ? (() => {
+            const lines: string[] = diag
+              .file!.text.substring(0, diag.start)
+              .split("\n");
+            if (lines.length === 0) return [0, 0];
+            return [lines.length, lines.at(-1)!.length + 1];
+          })()
+        : [0, 0];
+      console.error(
+        `${file}:${line}:${pos} - ${category} TS${diag.code}: ${diag.messageText}`,
+      );
+    }
+    if (diagnostics.length) process.exit(-1);
+
+    // ARCHIVE TRANSFORMED FILES
+    const printer: ts.Printer = ts.createPrinter({
+      newLine: ts.NewLineKind.LineFeed,
+    });
+    for (const file of result.transformed) {
+      const to: string = path
+        .resolve(file.fileName)
+        .replace(props.input, props.output);
+
+      const content: string = printer.printFile(file);
+      await fs.promises.writeFile(to, content, "utf8");
+    }
+  };
+
+  const is_directory = async (current: string): Promise<boolean> => {
+    const stat: fs.Stats = await fs.promises.stat(current);
+    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 is_supported_extension = (filename: string): boolean => {
+    return (
+      (filename.endsWith(".ts") && !filename.endsWith(".d.ts")) ||
+      (filename.endsWith(".tsx") && !filename.endsWith(".d.tsx"))
+    );
+  };
+}

package/src/programmers/ValidateProgrammer.ts

@@ -5,7 +5,8 @@ import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
 import { TypeFactory } from "../factories/TypeFactory";
 
-import { IProject } from "../transformers/IProject";
+import { IProgrammerProps } from "../transformers/IProgrammerProps";
+import { ITypiaContext } from "../transformers/ITypiaContext";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { FeatureProgrammer } from "./FeatureProgrammer";
@@ -16,11 +17,18 @@ import { check_everything } from "./internal/check_everything";
 import { check_object } from "./internal/check_object";
 
 export namespace ValidateProgrammer {
+  export interface IConfig {
+    equals: boolean;
+  }
+  export interface IProps extends IProgrammerProps {
+    config: IConfig;
+  }
+
   export const decompose = (props: {
-    project: IProject;
+    context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
     importer: FunctionImporter;
-    equals: boolean;
+    config: IConfig;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -31,8 +39,8 @@ export namespace ValidateProgrammer {
         prefix: "$v",
         path: true,
         trace: true,
-        numeric: OptionPredicator.numeric(props.project.options),
-        equals: props.equals,
+        numeric: OptionPredicator.numeric(props.context.options),
+        equals: props.config.equals,
         atomist: (explore) => (entry) => (input) =>
           [
             ...(entry.expression ? [entry.expression] : []),
@@ -84,8 +92,8 @@ export namespace ValidateProgrammer {
                     ),
                   ]),
           ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
-        combiner: combine(props.equals)(props.project)(props.importer),
-        joiner: joiner(props.equals)(props.project)(props.importer),
+        combiner: combine(props.config.equals)(props.context)(props.importer),
+        joiner: joiner(props.config.equals)(props.context)(props.importer),
         success: ts.factory.createTrue(),
       },
     });
@@ -96,7 +104,7 @@ export namespace ValidateProgrammer {
       ts.factory.createTypeReferenceNode(
         `typia.IValidation<${
           props.name ??
-          TypeFactory.getFullName(props.project.checker)(props.type)
+          TypeFactory.getFullName(props.context.checker)(props.type)
         }>`,
       ),
       undefined,
@@ -214,31 +222,29 @@ export namespace ValidateProgrammer {
     };
   };
 
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (type: ts.Type, name?: string) => {
-      const importer: FunctionImporter = new FunctionImporter(modulo.getText());
-      const result: FeatureProgrammer.IDecomposed = decompose({
-        equals,
-        project,
-        modulo,
-        importer,
-        type,
-        name,
-      });
-      return FeatureProgrammer.writeDecomposed({
-        modulo,
-        importer,
-        result,
-      });
-    };
+  export const write = (props: IProps) => {
+    const importer: FunctionImporter = new FunctionImporter(
+      props.modulo.getText(),
+    );
+    const result: FeatureProgrammer.IDecomposed = decompose({
+      config: props.config,
+      context: props.context,
+      modulo: props.modulo,
+      importer,
+      type: props.type,
+      name: props.name,
+    });
+    return FeatureProgrammer.writeDecomposed({
+      modulo: props.modulo,
+      importer,
+      result,
+    });
+  };
 }
 
 const combine =
   (equals: boolean) =>
-  (project: IProject) =>
+  (project: ITypiaContext) =>
   (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
   (explore: CheckerProgrammer.IExplore) => {
     if (explore.tracable === false)
@@ -279,7 +285,9 @@ const combine =
   };
 
 const validate_object =
-  (equals: boolean) => (project: IProject) => (importer: FunctionImporter) =>
+  (equals: boolean) =>
+  (project: ITypiaContext) =>
+  (importer: FunctionImporter) =>
     check_object({
       equals,
       undefined: true,
@@ -309,7 +317,7 @@ const validate_object =
 
 const joiner =
   (equals: boolean) =>
-  (project: IProject) =>
+  (project: ITypiaContext) =>
   (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
     object: validate_object(equals)(project)(importer),
     array: (input, arrow) =>

package/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts

@@ -4,7 +4,7 @@ import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { StringUtil } from "../../utils/StringUtil";
 
@@ -13,84 +13,100 @@ import { FunctionalAssertParametersProgrammer } from "./FunctionalAssertParamete
 import { FunctionAssertReturnProgrammer } from "./FunctionalAssertReturnProgrammer";
 
 export namespace FunctionalAssertFunctionProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-      init?: ts.Expression,
-    ): ts.CallExpression => {
-      const wrapper = errorFactoryWrapper(modulo)(declaration.parameters)(init);
-      const p = FunctionalAssertParametersProgrammer.decompose(project)(modulo)(
-        equals,
-      )(declaration.parameters, wrapper.name);
-      const r = FunctionAssertReturnProgrammer.decompose(project)(modulo)(
-        equals,
-      )(expression, declaration, wrapper.name);
-      return ExpressionFactory.selfCall(
-        ts.factory.createBlock(
-          [
-            wrapper.variable,
-            ...p.functions,
-            ...r.functions,
-            ts.factory.createReturnStatement(
-              ts.factory.createArrowFunction(
-                r.async
-                  ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                  : undefined,
-                undefined,
-                declaration.parameters,
-                declaration.type,
-                undefined,
-                ts.factory.createBlock([
-                  ...p.expressions.map(ts.factory.createExpressionStatement),
-                  ts.factory.createReturnStatement(r.value),
-                ]),
-              ),
-            ),
-          ],
-          true,
-        ),
-      );
-    };
+  export interface IConfig {
+    equals: boolean;
+  }
+  export interface IProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    declaration: ts.FunctionDeclaration;
+    expression: ts.Expression;
+    init?: ts.Expression | undefined;
+  }
 
-  export const errorFactoryWrapper =
-    (modulo: ts.LeftHandSideExpression) =>
-    (paramters: readonly ts.ParameterDeclaration[]) =>
-    (
-      init: ts.Expression | undefined,
-    ): {
-      name: string;
-      variable: ts.VariableStatement;
-    } => {
-      const name: string = StringUtil.escapeDuplicate(
-        paramters.map((p) => p.name.getText()),
-      )("errorFactoryWrapper");
-      const variable: ts.VariableStatement = ts.factory.createVariableStatement(
-        undefined,
-        ts.factory.createVariableDeclarationList(
-          [
-            ts.factory.createVariableDeclaration(
-              name,
+  export const write = (props: IProps): ts.CallExpression => {
+    const wrapper = errorFactoryWrapper({
+      modulo: props.modulo,
+      parameters: props.declaration.parameters,
+      init: props.init,
+    });
+    const p = FunctionalAssertParametersProgrammer.decompose({
+      context: props.context,
+      modulo: props.modulo,
+      config: props.config,
+      parameters: props.declaration.parameters,
+      wrapper: wrapper.name,
+    });
+    const r = FunctionAssertReturnProgrammer.decompose({
+      context: props.context,
+      modulo: props.modulo,
+      config: props.config,
+      expression: props.expression,
+      declaration: props.declaration,
+      wrapper: wrapper.name,
+    });
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          wrapper.variable,
+          ...p.functions,
+          ...r.functions,
+          ts.factory.createReturnStatement(
+            ts.factory.createArrowFunction(
+              r.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined,
               undefined,
-              AssertProgrammer.Guardian.type(),
-              init ??
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createAsExpression(
-                    modulo,
-                    TypeFactory.keyword("any"),
-                  ),
-                  "errorFactory",
-                ),
+              props.declaration.parameters,
+              props.declaration.type,
+              undefined,
+              ts.factory.createBlock([
+                ...p.expressions.map(ts.factory.createExpressionStatement),
+                ts.factory.createReturnStatement(r.value),
+              ]),
             ),
-          ],
-          ts.NodeFlags.Const,
-        ),
-      );
-      return { name, variable };
-    };
+          ),
+        ],
+        true,
+      ),
+    );
+  };
+
+  export const errorFactoryWrapper = (props: {
+    modulo: ts.LeftHandSideExpression;
+    parameters: readonly ts.ParameterDeclaration[];
+    init: ts.Expression | undefined;
+  }): {
+    name: string;
+    variable: ts.VariableStatement;
+  } => {
+    const name: string = StringUtil.escapeDuplicate(
+      props.parameters.map((p) => p.name.getText()),
+    )("errorFactoryWrapper");
+    const variable: ts.VariableStatement = ts.factory.createVariableStatement(
+      undefined,
+      ts.factory.createVariableDeclarationList(
+        [
+          ts.factory.createVariableDeclaration(
+            name,
+            undefined,
+            AssertProgrammer.Guardian.type(),
+            props.init ??
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createAsExpression(
+                  props.modulo,
+                  TypeFactory.keyword("any"),
+                ),
+                "errorFactory",
+              ),
+          ),
+        ],
+        ts.NodeFlags.Const,
+      ),
+    );
+    return { name, variable };
+  };
 
   export const hookPath = (props: {
     wrapper: string;