typia 5.1.6 → 5.2.0-dev.20231007

package/src/transformers/features/misc/MiscValidatePruneTransformer.ts

@@ -3,7 +3,7 @@ import { MiscValidatePruneProgrammer } from "../../../programmers/misc/MiscValid
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace MiscValidatePruneTransformer {
-    export const transform = GenericTransformer.scalar("validatPrune")(
+    export const transform = GenericTransformer.scalar("misc.validatPrune")(
         (project) => (modulo) =>
             MiscValidatePruneProgrammer.write(project)(modulo),
     );

package/src/transformers/features/notations/NotationAssertGeneralTransformer.ts

@@ -0,0 +1,15 @@
+import { NotationAssertGeneralProgrammer } from "../../../programmers/notations/NotationAssertGeneralProgrammer";
+
+import { StringUtil } from "../../../utils/StringUtil";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationAssertGeneralTransformer {
+    export const transform = (rename: (str: string) => string) =>
+        GenericTransformer.scalar(
+            `notations.assert${StringUtil.capitalize(rename.name)}`,
+        )(
+            (project) => (modulo) =>
+                NotationAssertGeneralProgrammer.write(rename)(project)(modulo),
+        );
+}

package/src/transformers/features/notations/NotationCreateAssertGeneralTransformer.ts

@@ -0,0 +1,15 @@
+import { NotationAssertGeneralProgrammer } from "../../../programmers/notations/NotationAssertGeneralProgrammer";
+
+import { StringUtil } from "../../../utils/StringUtil";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationCreateAssertGeneralTransformer {
+    export const transform = (rename: (str: string) => string) =>
+        GenericTransformer.factory(
+            `notations.createAssert${StringUtil.capitalize(rename.name)}`,
+        )(
+            (project) => (modulo) =>
+                NotationAssertGeneralProgrammer.write(rename)(project)(modulo),
+        );
+}

package/src/transformers/features/notations/NotationCreateGeneralTransformer.ts

@@ -0,0 +1,15 @@
+import { NotationGeneralProgrammer } from "../../../programmers/notations/NotationGeneralProgrammer";
+
+import { StringUtil } from "../../../utils/StringUtil";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationCreateGeneralTransformer {
+    export const transform = (rename: (str: string) => string) =>
+        GenericTransformer.factory(
+            `notations.create${StringUtil.capitalize(rename.name)}`,
+        )(
+            (project) => (modulo) =>
+                NotationGeneralProgrammer.write(rename)(project)(modulo),
+        );
+}

package/src/transformers/features/notations/NotationCreateIsGeneralTransformer.ts

@@ -0,0 +1,15 @@
+import { NotationIsGeneralProgrammer } from "../../../programmers/notations/NotationIsGeneralProgrammer";
+
+import { StringUtil } from "../../../utils/StringUtil";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationCreateIsGeneralTransformer {
+    export const transform = (rename: (str: string) => string) =>
+        GenericTransformer.factory(
+            `notations.createIs${StringUtil.capitalize(rename.name)}`,
+        )(
+            (project) => (modulo) =>
+                NotationIsGeneralProgrammer.write(rename)(project)(modulo),
+        );
+}

package/src/transformers/features/notations/NotationCreateValidateGeneralTransformer.ts

@@ -0,0 +1,17 @@
+import { NotationValidateGeneralProgrammer } from "../../../programmers/notations/NotationValidateGeneralProgrammer";
+
+import { StringUtil } from "../../../utils/StringUtil";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationCreateValidateGeneralTransformer {
+    export const transform = (rename: (str: string) => string) =>
+        GenericTransformer.factory(
+            `notations.createValidate${StringUtil.capitalize(rename.name)}`,
+        )(
+            (project) => (modulo) =>
+                NotationValidateGeneralProgrammer.write(rename)(project)(
+                    modulo,
+                ),
+        );
+}

package/src/transformers/features/notations/NotationGeneralTransformer.ts

@@ -0,0 +1,11 @@
+import { NotationGeneralProgrammer } from "../../../programmers/notations/NotationGeneralProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationGeneralTransformer {
+    export const transform = (rename: (str: string) => string) =>
+        GenericTransformer.scalar(`notations.${rename.name}`)(
+            (project) => (modulo) =>
+                NotationGeneralProgrammer.write(rename)(project)(modulo),
+        );
+}

package/src/transformers/features/notations/NotationIsGeneralTransformer.ts

@@ -0,0 +1,15 @@
+import { NotationIsGeneralProgrammer } from "../../../programmers/notations/NotationIsGeneralProgrammer";
+
+import { StringUtil } from "../../../utils/StringUtil";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationIsGeneralTransformer {
+    export const transform = (rename: (str: string) => string) =>
+        GenericTransformer.scalar(
+            `notations.is${StringUtil.capitalize(rename.name)}`,
+        )(
+            (project) => (modulo) =>
+                NotationIsGeneralProgrammer.write(rename)(project)(modulo),
+        );
+}

package/src/transformers/features/notations/NotationValidateGeneralTransformer.ts

@@ -0,0 +1,17 @@
+import { NotationValidateGeneralProgrammer } from "../../../programmers/notations/NotationValidateGeneralProgrammer";
+
+import { StringUtil } from "../../../utils/StringUtil";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationValidateGeneralTransformer {
+    export const transform = (rename: (str: string) => string) =>
+        GenericTransformer.scalar(
+            `notations.validate${StringUtil.capitalize(rename.name)}`,
+        )(
+            (project) => (modulo) =>
+                NotationValidateGeneralProgrammer.write(rename)(project)(
+                    modulo,
+                ),
+        );
+}

package/src/transformers/features/protobuf/{CreateProtobufAssertDecodeTransformer.ts → ProtobufCreateAssertDecodeTransformer.ts}

@@ -2,7 +2,7 @@ import { ProtobufAssertDecodeProgrammer } from "../../../programmers/protobuf/Pr
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
-export namespace CreateProtobufAssertDecodeTransformer {
+export namespace ProtobufCreateAssertDecodeTransformer {
     export const transform = GenericTransformer.factory(
         "protobuf.createAssertDecode",
     )(

package/src/transformers/features/protobuf/{CreateProtobufAssertEncodeTransformer.ts → ProtobufCreateAssertEncodeTransformer.ts}

@@ -2,7 +2,7 @@ import { ProtobufAssertEncodeProgrammer } from "../../../programmers/protobuf/Pr
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
-export namespace CreateProtobufAssertEncodeTransformer {
+export namespace ProtobufCreateAssertEncodeTransformer {
     export const transform = GenericTransformer.factory(
         "protobuf.createAssertEncode",
     )(

package/src/transformers/features/protobuf/{CreateProtobufDecodeTransformer.ts → ProtobufCreateDecodeTransformer.ts}

@@ -2,7 +2,7 @@ import { ProtobufDecodeProgrammer } from "../../../programmers/protobuf/Protobuf
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
-export namespace CreateProtobufDecodeTransformer {
+export namespace ProtobufCreateDecodeTransformer {
     export const transform = GenericTransformer.factory(
         "protobuf.createDecode",
     )((project) => (modulo) => ProtobufDecodeProgrammer.write(project)(modulo));

package/src/transformers/features/protobuf/{CreateProtobufEncodeTransformer.ts → ProtobufCreateEncodeTransformer.ts}

@@ -2,7 +2,7 @@ import { ProtobufEncodeProgrammer } from "../../../programmers/protobuf/Protobuf
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
-export namespace CreateProtobufEncodeTransformer {
+export namespace ProtobufCreateEncodeTransformer {
     export const transform = GenericTransformer.factory(
         "protobuf.createEncode",
     )((project) => (modulo) => ProtobufEncodeProgrammer.write(project)(modulo));

package/src/transformers/features/protobuf/{CreateProtobufIsDecodeTransformer.ts → ProtobufCreateIsDecodeTransformer.ts}

@@ -2,7 +2,7 @@ import { ProtobufIsDecodeProgrammer } from "../../../programmers/protobuf/Protob
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
-export namespace CreateProtobufIsDecodeTransformer {
+export namespace ProtobufCreateIsDecodeTransformer {
     export const transform = GenericTransformer.factory(
         "protobuf.createIsDecode",
     )(

package/src/transformers/features/protobuf/{CreateProtobufIsEncodeTransformer.ts → ProtobufCreateIsEncodeTransformer.ts}

@@ -2,7 +2,7 @@ import { ProtobufIsEncodeProgrammer } from "../../../programmers/protobuf/Protob
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
-export namespace CreateProtobufIsEncodeTransformer {
+export namespace ProtobufCreateIsEncodeTransformer {
     export const transform = GenericTransformer.factory(
         "protobuf.createIsEncode",
     )(

package/src/transformers/features/protobuf/{CreateProtobufValidateDecodeTransformer.ts → ProtobufCreateValidateDecodeTransformer.ts}

@@ -2,7 +2,7 @@ import { ProtobufValidateDecodeProgrammer } from "../../../programmers/protobuf/
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
-export namespace CreateProtobufValidateDecodeTransformer {
+export namespace ProtobufCreateValidateDecodeTransformer {
     export const transform = GenericTransformer.factory(
         "protobuf.createValidateDecode",
     )(

package/src/transformers/features/protobuf/{CreateProtobufValidateEncodeTransformer.ts → ProtobufCreateValidateEncodeTransformer.ts}

@@ -2,7 +2,7 @@ import { ProtobufValidateEncodeProgrammer } from "../../../programmers/protobuf/
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
-export namespace CreateProtobufValidateEncodeTransformer {
+export namespace ProtobufCreateValidateEncodeTransformer {
     export const transform = GenericTransformer.factory(
         "protobuf.createValidateEncode",
     )(

package/src/utils/NamingConvention.ts

@@ -0,0 +1,91 @@
+import { StringUtil } from "./StringUtil";
+
+export namespace NamingConvention {
+    export function snake(str: string): string {
+        const indexes: number[] = [];
+        for (let i: number = 0; i < str.length; i++) {
+            const code: number = str.charCodeAt(i);
+            if (65 <= code && code <= 90) indexes.push(i);
+        }
+        for (let i: number = indexes.length - 1; i > 0; --i) {
+            const now: number = indexes[i]!;
+            const prev: number = indexes[i - 1]!;
+            if (now - prev === 1) indexes.splice(i, 1);
+        }
+        if (indexes.length !== 0 && indexes[0] === 0) indexes.splice(0, 1);
+        if (indexes.length === 0) return str.toLowerCase();
+
+        let ret: string = "";
+        for (let i: number = 0; i < indexes.length; i++) {
+            const first: number = i === 0 ? 0 : indexes[i - 1]!;
+            const last: number = indexes[i]!;
+
+            ret += str.substring(first, last).toLowerCase();
+            ret += "_";
+        }
+        ret += str.substring(indexes[indexes.length - 1]!).toLowerCase();
+        return ret;
+    }
+
+    export function camel(str: string): string {
+        str = removeSnake(str);
+        if (str.length === 0) return str;
+        else if (str[0] === str[0]!.toUpperCase())
+            return str[0]!.toLowerCase() + str.substring(1);
+        else if (
+            str[0] === "_" &&
+            str.length > 1 &&
+            str[1] === str[1]!.toLowerCase()
+        )
+            return "_" + str[1]!.toUpperCase() + str.substring(2);
+        else return str;
+    }
+
+    export function pascal(str: string): string {
+        str = removeSnake(str);
+        if (str.length === 0) return str;
+        else if (str[0] === str[0]!.toLowerCase())
+            return str[0]!.toUpperCase() + str.substring(1);
+        else if (
+            str[0] === "_" &&
+            str.length > 1 &&
+            str[1] === str[1]!.toLowerCase()
+        )
+            return "_" + str[1]!.toUpperCase() + str.substring(2);
+        else return str;
+    }
+
+    const removeSnake = (str: string): string => {
+        const indexes: [number, number][] = [];
+        for (let i: number = 0; i < str.length; i++) {
+            const ch: string = str[i]!;
+            if (ch !== "_") continue;
+
+            const last = indexes[indexes.length - 1];
+            if (last === undefined || last[0] + last[1] !== i)
+                indexes.push([i, 1]);
+            else ++last[1];
+        }
+        if (indexes.length === 0) return str;
+
+        let ret: string = "";
+        for (let i: number = 0; i < indexes.length; i++) {
+            const [first] = indexes[i]!;
+            if (i === 0)
+                if (first === 0) ret += "_";
+                else ret += str.substring(0, first);
+            else {
+                const [prevFirst, prevLength] = indexes[i - 1]!;
+                const piece: string = str.substring(
+                    prevFirst + prevLength,
+                    first,
+                );
+                if (piece.length) ret += StringUtil.capitalize(piece);
+            }
+        }
+        const last = indexes[indexes.length - 1]!;
+        const piece: string = str.substring(last[0] + last[1]);
+        if (last.length) ret += StringUtil.capitalize(piece);
+        return ret;
+    };
+}

package/src/utils/StringUtil.ts

@@ -0,0 +1,4 @@
+export namespace StringUtil {
+    export const capitalize = (str: string) =>
+        str.length ? str[0]!.toUpperCase() + str.slice(1) : str;
+}