typia 4.1.6 → 5.0.0-dev.20230713

package/src/transformers/CallExpressionTransformer.ts

@@ -1,179 +1,196 @@
-import path from "path";
-import ts from "typescript";
-
-import { IProject } from "./IProject";
-import { ApplicationTransformer } from "./features/miscellaneous/ApplicationTransformer";
-import { AssertCloneTransformer } from "./features/miscellaneous/AssertCloneTransformer";
-import { AssertPruneTransformer } from "./features/miscellaneous/AssertPruneTransformer";
-import { CloneTransformer } from "./features/miscellaneous/CloneTransformer";
-import { CreateAssertCloneTransformer } from "./features/miscellaneous/CreateAssertCloneTransformer";
-import { CreateAssertPruneTransformer } from "./features/miscellaneous/CreateAssertPruneTransformer";
-import { CreateCloneTransformer } from "./features/miscellaneous/CreateCloneTransformer";
-import { CreateIsCloneTransformer } from "./features/miscellaneous/CreateIsCloneTransformer";
-import { CreateIsPruneTransformer } from "./features/miscellaneous/CreateIsPruneTransformer";
-import { CreatePruneTransformer } from "./features/miscellaneous/CreatePruneTransformer";
-import { CreateRandomTransformer } from "./features/miscellaneous/CreateRandomTransformer";
-import { CreateValidateCloneTransformer } from "./features/miscellaneous/CreateValidateCloneTransformer";
-import { CreateValidatePruneTransformer } from "./features/miscellaneous/CreateValidatePruneTransformer";
-import { IsCloneTransformer } from "./features/miscellaneous/IsCloneTransformer";
-import { IsPruneTransformer } from "./features/miscellaneous/IsPruneTransformer";
-import { LiteralsTransformer } from "./features/miscellaneous/LiteralsTransformer";
-import { MetadataTransformer } from "./features/miscellaneous/MetadataTransformer";
-import { PruneTransformer } from "./features/miscellaneous/PruneTransformer";
-import { RandomTransformer } from "./features/miscellaneous/RandomTransformer";
-import { ValidateCloneTransformer } from "./features/miscellaneous/ValidateCloneTransformer";
-import { ValidatePruneTransformer } from "./features/miscellaneous/ValidatePruneTransformer";
-import { AssertParseTransformer } from "./features/parsers/AssertParseTransformer";
-import { CreateAssertParseTransformer } from "./features/parsers/CreateAssertParseTransformer";
-import { CreateIsParseTransformer } from "./features/parsers/CreateIsParseTransformer";
-import { CreateValidateParseTransformer } from "./features/parsers/CreateValidateParseTransformer";
-import { IsParseTransformer } from "./features/parsers/IsParseTransformer";
-import { ValidateParseTransformer } from "./features/parsers/ValidateParseTransformer";
-import { AssertStringifyTransformer } from "./features/stringifiers/AssertStringifyTransformer";
-import { CreateAssertStringifyTransformer } from "./features/stringifiers/CreateAssertStringifyTransformer";
-import { CreateIsStringifyTransformer } from "./features/stringifiers/CreateIsStringifyTransformer";
-import { CreateStringifyTransformer } from "./features/stringifiers/CreateStringifyTransformer";
-import { CreateValidateStringifyTransformer } from "./features/stringifiers/CreateValidateStringifyProgrammer";
-import { IsStringifyTransformer } from "./features/stringifiers/IsStringifyTransformer";
-import { StringifyTransformer } from "./features/stringifiers/StringifyTransformer";
-import { ValidateStringifyTransformer } from "./features/stringifiers/ValidateStringifyTransformer";
-import { AssertTransformer } from "./features/validators/AssertTransformer";
-import { CreateAssertTransformer } from "./features/validators/CreateAssertTransformer";
-import { CreateIsTransformer } from "./features/validators/CreateIsTransformer";
-import { CreateValidateTransformer } from "./features/validators/CreateValidateTransformer";
-import { IsTransformer } from "./features/validators/IsTransformer";
-import { ValidateTransformer } from "./features/validators/ValidateTransformer";
-
-export namespace CallExpressionTransformer {
-    export const transform =
-        (project: IProject) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            //----
-            // VALIDATIONS
-            //----
-            // SIGNATURE DECLARATION
-            const declaration: ts.Declaration | undefined =
-                project.checker.getResolvedSignature(expression)?.declaration;
-            if (!declaration) return expression;
-
-            // FILE PATH
-            const file: string = path.resolve(
-                declaration.getSourceFile().fileName,
-            );
-            if (
-                file.indexOf(LIB_PATH) === -1 &&
-                file !== SRC_PATH &&
-                file !== CLI_PATH
-            )
-                return expression;
-
-            //----
-            // TRANSFORMATION
-            //----
-            // FUNCTION NAME
-            const { name } =
-                project.checker.getTypeAtLocation(declaration).symbol;
-
-            // FIND TRANSFORMER
-            const functor: (() => Task) | undefined = FUNCTORS[name];
-            if (functor === undefined) return expression;
-
-            // console.log(expression.getSourceFile().fileName);
-
-            // RETURNS WITH TRANSFORMATION
-            return functor()(project)(expression.expression)(expression);
-        };
-}
-
-type Task = (
-    project: IProject,
-) => (
-    modulo: ts.LeftHandSideExpression,
-) => (expression: ts.CallExpression) => ts.Expression;
-
-const LIB_PATH = path.join("node_modules", "typia", "lib", "module.d.ts");
-const SRC_PATH = path.resolve(path.join(__dirname, "..", "module.ts"));
-const CLI_PATH = path.resolve(
-    path.join(__dirname, "..", "..", "..", "src", "module.ts"),
-);
-
-const FUNCTORS: Record<string, () => Task> = {
-    //----
-    // SINGLE FUNCTIONS
-    //----
-    // BASIC VALIDATORS
-    assert: () => AssertTransformer.transform(false),
-    assertType: () => AssertTransformer.transform(false),
-    is: () => IsTransformer.transform(false),
-    validate: () => ValidateTransformer.transform(false),
-
-    // STRICT VALIDATORS
-    assertEquals: () => AssertTransformer.transform(true),
-    equals: () => IsTransformer.transform(true),
-    validateEquals: () => ValidateTransformer.transform(true),
-
-    // PARSE FUNCTIONS
-    isParse: () => IsParseTransformer.transform,
-    assertParse: () => AssertParseTransformer.transform,
-    validateParse: () => ValidateParseTransformer.transform,
-
-    // STRINGIFY FUNCTIONS
-    application: () => (project) => () =>
-        ApplicationTransformer.transform(project),
-    stringify: () => StringifyTransformer.transform,
-    assertStringify: () => AssertStringifyTransformer.transform,
-    isStringify: () => IsStringifyTransformer.transform,
-    validateStringify: () => ValidateStringifyTransformer.transform,
-
-    // MISC
-    metadata: () => (project) => () => MetadataTransformer.transform(project),
-    random: () => RandomTransformer.transform,
-    literals: () => (project) => () => LiteralsTransformer.transform(project),
-
-    clone: () => CloneTransformer.transform,
-    assertClone: () => AssertCloneTransformer.transform,
-    isClone: () => IsCloneTransformer.transform,
-    validateClone: () => ValidateCloneTransformer.transform,
-
-    prune: () => PruneTransformer.transform,
-    assertPrune: () => AssertPruneTransformer.transform,
-    isPrune: () => IsPruneTransformer.transform,
-    validatePrune: () => ValidatePruneTransformer.transform,
-
-    //----
-    // FACTORY FUNCTIONS
-    //----
-    // BASIC VALIDATORS
-    createAssert: () => CreateAssertTransformer.transform(false),
-    createAssertType: () => CreateAssertTransformer.transform(false),
-    createIs: () => CreateIsTransformer.transform(false),
-    createValidate: () => CreateValidateTransformer.transform(false),
-
-    // STRICT VALIDATORS
-    createAssertEquals: () => CreateAssertTransformer.transform(true),
-    createEquals: () => CreateIsTransformer.transform(true),
-    createValidateEquals: () => CreateValidateTransformer.transform(true),
-
-    // PARSE FUNCTIONS
-    createIsParse: () => CreateIsParseTransformer.transform,
-    createAssertParse: () => CreateAssertParseTransformer.transform,
-    createValidateParse: () => CreateValidateParseTransformer.transform,
-
-    // STRINGIFY FUNCTIONS
-    createStringify: () => CreateStringifyTransformer.transform,
-    createAssertStringify: () => CreateAssertStringifyTransformer.transform,
-    createIsStringify: () => CreateIsStringifyTransformer.transform,
-    createValidateStringify: () => CreateValidateStringifyTransformer.transform,
-
-    // MISC
-    createRandom: () => CreateRandomTransformer.transform,
-    createClone: () => CreateCloneTransformer.transform,
-    createAssertClone: () => CreateAssertCloneTransformer.transform,
-    createIsClone: () => CreateIsCloneTransformer.transform,
-    createValidateClone: () => CreateValidateCloneTransformer.transform,
-
-    createPrune: () => CreatePruneTransformer.transform,
-    createAssertPrune: () => CreateAssertPruneTransformer.transform,
-    createIsPrune: () => CreateIsPruneTransformer.transform,
-    createValidatePrune: () => CreateValidatePruneTransformer.transform,
-};
+import path from "path";
+import ts from "typescript";
+
+import { IProject } from "./IProject";
+import { AssertTransformer } from "./features/AssertTransformer";
+import { CreateAssertTransformer } from "./features/CreateAssertTransformer";
+import { CreateIsTransformer } from "./features/CreateIsTransformer";
+import { CreateRandomTransformer } from "./features/CreateRandomTransformer";
+import { CreateValidateTransformer } from "./features/CreateValidateTransformer";
+import { IsTransformer } from "./features/IsTransformer";
+import { RandomTransformer } from "./features/RandomTransformer";
+import { ValidateTransformer } from "./features/ValidateTransformer";
+import { AssertParseTransformer } from "./features/json/AssertParseTransformer";
+import { AssertStringifyTransformer } from "./features/json/AssertStringifyTransformer";
+import { CreateAssertParseTransformer } from "./features/json/CreateAssertParseTransformer";
+import { CreateAssertStringifyTransformer } from "./features/json/CreateAssertStringifyTransformer";
+import { CreateIsParseTransformer } from "./features/json/CreateIsParseTransformer";
+import { CreateIsStringifyTransformer } from "./features/json/CreateIsStringifyTransformer";
+import { CreateStringifyTransformer } from "./features/json/CreateStringifyTransformer";
+import { CreateValidateParseTransformer } from "./features/json/CreateValidateParseTransformer";
+import { CreateValidateStringifyTransformer } from "./features/json/CreateValidateStringifyProgrammer";
+import { IsParseTransformer } from "./features/json/IsParseTransformer";
+import { IsStringifyTransformer } from "./features/json/IsStringifyTransformer";
+import { StringifyTransformer } from "./features/json/StringifyTransformer";
+import { ValidateParseTransformer } from "./features/json/ValidateParseTransformer";
+import { ValidateStringifyTransformer } from "./features/json/ValidateStringifyTransformer";
+import { ApplicationTransformer } from "./features/misc/ApplicationTransformer";
+import { AssertCloneTransformer } from "./features/misc/AssertCloneTransformer";
+import { AssertPruneTransformer } from "./features/misc/AssertPruneTransformer";
+import { CloneTransformer } from "./features/misc/CloneTransformer";
+import { CreateAssertCloneTransformer } from "./features/misc/CreateAssertCloneTransformer";
+import { CreateAssertPruneTransformer } from "./features/misc/CreateAssertPruneTransformer";
+import { CreateCloneTransformer } from "./features/misc/CreateCloneTransformer";
+import { CreateIsCloneTransformer } from "./features/misc/CreateIsCloneTransformer";
+import { CreateIsPruneTransformer } from "./features/misc/CreateIsPruneTransformer";
+import { CreatePruneTransformer } from "./features/misc/CreatePruneTransformer";
+import { CreateValidateCloneTransformer } from "./features/misc/CreateValidateCloneTransformer";
+import { CreateValidatePruneTransformer } from "./features/misc/CreateValidatePruneTransformer";
+import { IsCloneTransformer } from "./features/misc/IsCloneTransformer";
+import { IsPruneTransformer } from "./features/misc/IsPruneTransformer";
+import { LiteralsTransformer } from "./features/misc/LiteralsTransformer";
+import { MetadataTransformer } from "./features/misc/MetadataTransformer";
+import { PruneTransformer } from "./features/misc/PruneTransformer";
+import { ValidateCloneTransformer } from "./features/misc/ValidateCloneTransformer";
+import { ValidatePruneTransformer } from "./features/misc/ValidatePruneTransformer";
+import { MessageTransformer } from "./features/protobuf/MessageTransformer";
+
+export namespace CallExpressionTransformer {
+    export const transform =
+        (project: IProject) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            //----
+            // VALIDATIONS
+            //----
+            // SIGNATURE DECLARATION
+            const declaration: ts.Declaration | undefined =
+                project.checker.getResolvedSignature(expression)?.declaration;
+            if (!declaration) return expression;
+
+            // FILE PATH
+            const location: string = path.resolve(
+                declaration.getSourceFile().fileName,
+            );
+            if (isTarget(location) === false) return expression;
+
+            //----
+            // TRANSFORMATION
+            //----
+            // FUNCTION NAME
+            const module: string = location
+                .split(path.sep)
+                .at(-1)!
+                .split(".")[0]!;
+            const { name } =
+                project.checker.getTypeAtLocation(declaration).symbol;
+
+            // FIND TRANSFORMER
+            const functor: (() => Task) | undefined = FUNCTORS[module]?.[name];
+            if (functor === undefined) return expression;
+
+            // RETURNS WITH TRANSFORMATION
+            return functor()(project)(expression.expression)(expression);
+        };
+
+    const isTarget = (location: string): boolean => {
+        const files: string[] = Object.keys(FUNCTORS);
+        return files.some(
+            (f) =>
+                location.includes(
+                    path.join("node_modules", "typia", "lib", `${f}.d.ts`),
+                ) ||
+                location ===
+                    path.resolve(path.join(__dirname, "..", `${f}.ts`)) ||
+                location ===
+                    path.resolve(
+                        path.join(
+                            __dirname,
+                            "..",
+                            "..",
+                            "..",
+                            "src",
+                            `${f}.ts`,
+                        ),
+                    ),
+        );
+    };
+}
+
+type Task = (
+    project: IProject,
+) => (
+    modulo: ts.LeftHandSideExpression,
+) => (expression: ts.CallExpression) => ts.Expression;
+
+const FUNCTORS: Record<string, Record<string, () => Task>> = {
+    module: {
+        // BASIC
+        assert: () => AssertTransformer.transform(false),
+        assertType: () => AssertTransformer.transform(false),
+        is: () => IsTransformer.transform(false),
+        validate: () => ValidateTransformer.transform(false),
+
+        // STRICT
+        assertEquals: () => AssertTransformer.transform(true),
+        equals: () => IsTransformer.transform(true),
+        validateEquals: () => ValidateTransformer.transform(true),
+
+        // RANDOM + INTERNAL
+        random: () => RandomTransformer.transform,
+        metadata: () => (P) => () => MetadataTransformer.transform(P),
+
+        // FACTORIES
+        createAssert: () => CreateAssertTransformer.transform(false),
+        createAssertType: () => CreateAssertTransformer.transform(false),
+        createIs: () => CreateIsTransformer.transform(false),
+        createValidate: () => CreateValidateTransformer.transform(false),
+        createAssertEquals: () => CreateAssertTransformer.transform(true),
+        createEquals: () => CreateIsTransformer.transform(true),
+        createValidateEquals: () => CreateValidateTransformer.transform(true),
+        createRandom: () => CreateRandomTransformer.transform,
+    },
+    protobuf: {
+        message: () => MessageTransformer.transform,
+    },
+    json: {
+        // SCHEMA
+        application: () => (P) => () => ApplicationTransformer.transform(P),
+
+        // PARSER
+        isParse: () => IsParseTransformer.transform,
+        assertParse: () => AssertParseTransformer.transform,
+        validateParse: () => ValidateParseTransformer.transform,
+
+        // STRINGIFY
+        stringify: () => StringifyTransformer.transform,
+        assertStringify: () => AssertStringifyTransformer.transform,
+        isStringify: () => IsStringifyTransformer.transform,
+        validateStringify: () => ValidateStringifyTransformer.transform,
+
+        // FACTORIES
+        createIsParse: () => CreateIsParseTransformer.transform,
+        createAssertParse: () => CreateAssertParseTransformer.transform,
+        createValidateParse: () => CreateValidateParseTransformer.transform,
+        createStringify: () => CreateStringifyTransformer.transform,
+        createAssertStringify: () => CreateAssertStringifyTransformer.transform,
+        createIsStringify: () => CreateIsStringifyTransformer.transform,
+        createValidateStringify: () =>
+            CreateValidateStringifyTransformer.transform,
+    },
+    misc: {
+        literals: () => (project) => () =>
+            LiteralsTransformer.transform(project),
+
+        // CLONE
+        clone: () => CloneTransformer.transform,
+        assertClone: () => AssertCloneTransformer.transform,
+        isClone: () => IsCloneTransformer.transform,
+        validateClone: () => ValidateCloneTransformer.transform,
+
+        // PRUNE
+        prune: () => PruneTransformer.transform,
+        assertPrune: () => AssertPruneTransformer.transform,
+        isPrune: () => IsPruneTransformer.transform,
+        validatePrune: () => ValidatePruneTransformer.transform,
+
+        // FACTORIES
+        createClone: () => CreateCloneTransformer.transform,
+        createAssertClone: () => CreateAssertCloneTransformer.transform,
+        createIsClone: () => CreateIsCloneTransformer.transform,
+        createValidateClone: () => CreateValidateCloneTransformer.transform,
+        createPrune: () => CreatePruneTransformer.transform,
+        createAssertPrune: () => CreateAssertPruneTransformer.transform,
+        createIsPrune: () => CreateIsPruneTransformer.transform,
+        createValidatePrune: () => CreateValidatePruneTransformer.transform,
+    },
+};

package/src/transformers/features/{validators/AssertTransformer.ts → AssertTransformer.ts}

@@ -1,6 +1,6 @@
-import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
+import { AssertProgrammer } from "../../programmers/AssertProgrammer";
 
-import { GenericTransformer } from "../../internal/GenericTransformer";
+import { GenericTransformer } from "../internal/GenericTransformer";
 
 export namespace AssertTransformer {
     export const transform = (equals: boolean) =>

package/src/transformers/features/{validators/CreateAssertTransformer.ts → CreateAssertTransformer.ts}

@@ -1,6 +1,6 @@
-import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
+import { AssertProgrammer } from "../../programmers/AssertProgrammer";
 
-import { GenericTransformer } from "../../internal/GenericTransformer";
+import { GenericTransformer } from "../internal/GenericTransformer";
 
 export namespace CreateAssertTransformer {
     export const transform = (equals: boolean) =>

package/src/transformers/features/{validators/CreateIsTransformer.ts → CreateIsTransformer.ts}

@@ -1,6 +1,6 @@
-import { IsProgrammer } from "../../../programmers/IsProgrammer";
+import { IsProgrammer } from "../../programmers/IsProgrammer";
 
-import { GenericTransformer } from "../../internal/GenericTransformer";
+import { GenericTransformer } from "../internal/GenericTransformer";
 
 export namespace CreateIsTransformer {
     export const transform = (equals: boolean) =>

package/src/transformers/features/{miscellaneous/CreateRandomTransformer.ts → CreateRandomTransformer.ts}

@@ -1,8 +1,8 @@
 import ts from "typescript";
 
-import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
+import { RandomProgrammer } from "../../programmers/RandomProgrammer";
 
-import { IProject } from "../../IProject";
+import { IProject } from "../IProject";
 
 export namespace CreateRandomTransformer {
     export const transform =

package/src/transformers/features/{validators/CreateValidateTransformer.ts → CreateValidateTransformer.ts}

@@ -1,6 +1,6 @@
-import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
+import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
 
-import { GenericTransformer } from "../../internal/GenericTransformer";
+import { GenericTransformer } from "../internal/GenericTransformer";
 
 export namespace CreateValidateTransformer {
     export const transform = (equals: boolean) =>

package/src/transformers/features/{validators/IsTransformer.ts → IsTransformer.ts}

@@ -1,6 +1,6 @@
-import { IsProgrammer } from "../../../programmers/IsProgrammer";
+import { IsProgrammer } from "../../programmers/IsProgrammer";
 
-import { GenericTransformer } from "../../internal/GenericTransformer";
+import { GenericTransformer } from "../internal/GenericTransformer";
 
 export namespace IsTransformer {
     export const transform = (equals: boolean) =>

package/src/transformers/features/{miscellaneous/RandomTransformer.ts → RandomTransformer.ts}

@@ -1,8 +1,8 @@
 import ts from "typescript";
 
-import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
+import { RandomProgrammer } from "../../programmers/RandomProgrammer";
 
-import { IProject } from "../../IProject";
+import { IProject } from "../IProject";
 
 export namespace RandomTransformer {
     export const transform =

package/src/transformers/features/{validators/ValidateTransformer.ts → ValidateTransformer.ts}

@@ -1,6 +1,6 @@
-import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
+import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
 
-import { GenericTransformer } from "../../internal/GenericTransformer";
+import { GenericTransformer } from "../internal/GenericTransformer";
 
 export namespace ValidateTransformer {
     export const transform = (equals: boolean) =>

package/src/transformers/features/{parsers → json}/AssertParseTransformer.ts

@@ -1,9 +1,10 @@
-import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
+import { JsonAssertParseProgrammer } from "../../../programmers/json/JsonAssertParseProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace AssertParseTransformer {
     export const transform = GenericTransformer.scalar("assertParse")(
-        (project) => (modulo) => AssertParseProgrammer.write(project)(modulo),
+        (project) => (modulo) =>
+            JsonAssertParseProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{stringifiers → json}/AssertStringifyTransformer.ts

@@ -1,10 +1,10 @@
-import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
+import { JsonAssertStringifyProgrammer } from "../../../programmers/json/JsonAssertStringifyProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace AssertStringifyTransformer {
     export const transform = GenericTransformer.scalar("assertStringify")(
         (project) => (modulo) =>
-            AssertStringifyProgrammer.write(project)(modulo),
+            JsonAssertStringifyProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{parsers → json}/CreateAssertParseTransformer.ts

@@ -1,9 +1,10 @@
-import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
+import { JsonAssertParseProgrammer } from "../../../programmers/json/JsonAssertParseProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateAssertParseTransformer {
     export const transform = GenericTransformer.factory("createAssertParse")(
-        (project) => (modulo) => AssertParseProgrammer.write(project)(modulo),
+        (project) => (modulo) =>
+            JsonAssertParseProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{stringifiers → json}/CreateAssertStringifyTransformer.ts

@@ -1,4 +1,4 @@
-import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
+import { JsonAssertStringifyProgrammer } from "../../../programmers/json/JsonAssertStringifyProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
@@ -7,6 +7,6 @@ export namespace CreateAssertStringifyTransformer {
         "createAssertStringify",
     )(
         (project) => (modulo) =>
-            AssertStringifyProgrammer.write(project)(modulo),
+            JsonAssertStringifyProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{parsers → json}/CreateIsParseTransformer.ts

@@ -1,9 +1,9 @@
-import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
+import { JsonIsParseProgrammer } from "../../../programmers/json/JsonIsParseProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateIsParseTransformer {
     export const transform = GenericTransformer.factory("createIsParse")(
-        (project) => (modulo) => IsParseProgrammer.write(project)(modulo),
+        (project) => (modulo) => JsonIsParseProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{stringifiers → json}/CreateIsStringifyTransformer.ts

@@ -1,4 +1,4 @@
-import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
+import { IsStringifyProgrammer } from "../../../programmers/json/JsonIsStringifyProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 

package/src/transformers/features/{stringifiers → json}/CreateStringifyTransformer.ts

@@ -1,9 +1,9 @@
-import { StringifyProgrammer } from "../../../programmers/StringifyProgrammer";
+import { JsonStringifyProgrammer } from "../../../programmers/json/JsonStringifyProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateStringifyTransformer {
     export const transform = GenericTransformer.factory("createStringify")(
-        (project) => (modulo) => StringifyProgrammer.write(project)(modulo),
+        (project) => (modulo) => JsonStringifyProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{parsers → json}/CreateValidateParseTransformer.ts

@@ -1,9 +1,10 @@
-import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
+import { JsonValidateParseProgrammer } from "../../../programmers/json/JsonValidateParseProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateValidateParseTransformer {
     export const transform = GenericTransformer.factory("createValidateParse")(
-        (project) => (modulo) => ValidateParseProgrammer.write(project)(modulo),
+        (project) => (modulo) =>
+            JsonValidateParseProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{stringifiers → json}/CreateValidateStringifyProgrammer.ts

@@ -1,4 +1,4 @@
-import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
+import { JsonValidateStringifyProgrammer } from "../../../programmers/json/JsonValidateStringifyProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
@@ -7,6 +7,6 @@ export namespace CreateValidateStringifyTransformer {
         "createValidateStringify",
     )(
         (project) => (modulo) =>
-            ValidateStringifyProgrammer.write(project)(modulo),
+            JsonValidateStringifyProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{parsers → json}/IsParseTransformer.ts

@@ -1,9 +1,9 @@
-import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
+import { JsonIsParseProgrammer } from "../../../programmers/json/JsonIsParseProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace IsParseTransformer {
     export const transform = GenericTransformer.scalar("isParse")(
-        (project) => (modulo) => IsParseProgrammer.write(project)(modulo),
+        (project) => (modulo) => JsonIsParseProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{stringifiers → json}/IsStringifyTransformer.ts

@@ -1,4 +1,4 @@
-import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
+import { IsStringifyProgrammer } from "../../../programmers/json/JsonIsStringifyProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";