typia 5.1.6-dev.20231005 → 5.2.0-dev.20231007

package/src/SnakeCase.ts

@@ -0,0 +1,156 @@
+/**
+ * Snake case type.
+ *
+ * `SnakeCase` type is a type that all keys of an object are converted to snake case.
+ *
+ * It also erase every method properties like {@link Resolved} type.
+ *
+ * @template T Target type to be snake cased
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type SnakeCase<T> = Equal<T, SnakageMain<T>> extends true
+    ? T
+    : SnakageMain<T>;
+
+/* -----------------------------------------------------------
+    OBJECT CONVERSION
+----------------------------------------------------------- */
+type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
+
+type SnakageMain<T> = T extends [never]
+    ? never // special trick for (jsonable | null) type
+    : T extends { valueOf(): boolean | bigint | number | string }
+    ? ValueOf<T>
+    : T extends Function
+    ? never
+    : T extends object
+    ? SnakageObject<T>
+    : T;
+
+type SnakageObject<T extends object> = T extends Array<infer U>
+    ? IsTuple<T> extends true
+        ? SnakageTuple<T>
+        : SnakageMain<U>[]
+    : T extends Set<infer U>
+    ? Set<SnakageMain<U>>
+    : T extends Map<infer K, infer V>
+    ? Map<SnakageMain<K>, SnakageMain<V>>
+    : T extends WeakSet<any> | WeakMap<any, any>
+    ? never
+    : T extends
+          | Date
+          | Uint8Array
+          | Uint8ClampedArray
+          | Uint16Array
+          | Uint32Array
+          | BigUint64Array
+          | Int8Array
+          | Int16Array
+          | Int32Array
+          | BigInt64Array
+          | Float32Array
+          | Float64Array
+          | ArrayBuffer
+          | SharedArrayBuffer
+          | DataView
+    ? T
+    : {
+          [Key in keyof T as SnakageString<Key & string>]: SnakageMain<T[Key]>;
+      };
+
+/* -----------------------------------------------------------
+    SPECIAL CASES
+----------------------------------------------------------- */
+type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
+    never,
+]
+    ? false
+    : T extends readonly any[]
+    ? number extends T["length"]
+        ? false
+        : true
+    : false;
+type SnakageTuple<T extends readonly any[]> = T extends []
+    ? []
+    : T extends [infer F]
+    ? [SnakageMain<F>]
+    : T extends [infer F, ...infer Rest extends readonly any[]]
+    ? [SnakageMain<F>, ...SnakageTuple<Rest>]
+    : T extends [(infer F)?]
+    ? [SnakageMain<F>?]
+    : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+    ? [SnakageMain<F>?, ...SnakageTuple<Rest>]
+    : [];
+
+type ValueOf<Instance> = IsValueOf<Instance, Boolean> extends true
+    ? boolean
+    : IsValueOf<Instance, Number> extends true
+    ? number
+    : IsValueOf<Instance, String> extends true
+    ? string
+    : Instance;
+
+type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object
+    ? Object extends IValueOf<infer Primitive>
+        ? Instance extends Primitive
+            ? false
+            : true // not Primitive, but Object
+        : false // cannot be
+    : false;
+
+interface IValueOf<T> {
+    valueOf(): T;
+}
+
+/* -----------------------------------------------------------
+    STRING CONVERTER
+----------------------------------------------------------- */
+type SnakageString<Key extends string> = Key extends `${infer _}`
+    ? SnakageStringRepeatedly<Key, "">
+    : Key;
+type SnakageStringRepeatedly<
+    S extends string,
+    Previous extends string,
+> = S extends `${infer First}${infer Second}${infer Rest}`
+    ? `${Underscore<Previous, First>}${Lowercase<First>}${Underscore<
+          First,
+          Second
+      >}${Lowercase<Second>}${SnakageStringRepeatedly<Rest, Second>}`
+    : S extends `${infer First}`
+    ? `${Underscore<Previous, First>}${Lowercase<First>}`
+    : "";
+type Underscore<First extends string, Second extends string> = First extends
+    | UpperAlphabetic
+    | ""
+    | "_"
+    ? ""
+    : Second extends UpperAlphabetic
+    ? "_"
+    : "";
+type UpperAlphabetic =
+    | "A"
+    | "B"
+    | "C"
+    | "D"
+    | "E"
+    | "F"
+    | "G"
+    | "H"
+    | "I"
+    | "J"
+    | "K"
+    | "L"
+    | "M"
+    | "N"
+    | "O"
+    | "P"
+    | "Q"
+    | "R"
+    | "S"
+    | "T"
+    | "U"
+    | "V"
+    | "W"
+    | "X"
+    | "Y"
+    | "Z";

package/src/functional/$convention.ts

@@ -0,0 +1,40 @@
+export const $convention = (rename: (str: string) => string) => {
+    const main = (input: any): any => {
+        if (typeof input === "object")
+            if (input === null) return null;
+            else if (Array.isArray(input)) return input.map(main);
+            else if (
+                input instanceof Boolean ||
+                input instanceof BigInt ||
+                input instanceof Number ||
+                input instanceof String
+            )
+                return input.valueOf();
+            else if (input instanceof Date) return new Date(input);
+            else if (
+                input instanceof Uint8Array ||
+                input instanceof Uint8ClampedArray ||
+                input instanceof Uint16Array ||
+                input instanceof Uint32Array ||
+                input instanceof BigUint64Array ||
+                input instanceof Int8Array ||
+                input instanceof Int16Array ||
+                input instanceof Int32Array ||
+                input instanceof BigInt64Array ||
+                input instanceof Float32Array ||
+                input instanceof Float64Array ||
+                input instanceof DataView
+            )
+                return input;
+            else return object(input);
+        return input;
+    };
+    const object = (input: Record<string, any>) =>
+        Object.fromEntries(
+            Object.entries(input).map(([key, value]) => [
+                rename(key),
+                main(value),
+            ]),
+        );
+    return main;
+};

package/src/functional/Namespace.ts

@@ -1,3 +1,4 @@
+import { NamingConvention } from "../utils/NamingConvention";
 import { RandomGenerator } from "../utils/RandomGenerator";
 
 import { IValidation } from "../IValidation";
@@ -9,6 +10,7 @@ import { $ProtobufSizer } from "./$ProtobufSizer";
 import { $ProtobufWriter } from "./$ProtobufWriter";
 import { $QueryReader } from "./$QueryReader";
 import { $any } from "./$any";
+import { $convention } from "./$convention";
 import { $every } from "./$every";
 import { $guard } from "./$guard";
 import { $is_between } from "./$is_between";
@@ -126,6 +128,26 @@ export namespace Namespace {
         });
     }
 
+    export namespace notations {
+        export const camel = (method: string) => ({
+            ...base(method),
+            any: $convention(NamingConvention.camel),
+        });
+        export const pascal = (method: string) => ({
+            ...base(method),
+            any: $convention(NamingConvention.pascal),
+        });
+        export const snake = (method: string) => ({
+            ...base(method),
+            any: $convention(NamingConvention.snake),
+        });
+
+        const base = (method: string) => ({
+            ...is(),
+            throws: $throws(`notations.${method}`),
+        });
+    }
+
     export const random = () => ({
         generator: RandomGenerator,
         pick: RandomGenerator.pick,

package/src/module.ts

@@ -9,6 +9,7 @@ import { Resolved } from "./Resolved";
 export * as http from "./http";
 export * as json from "./json";
 export * as misc from "./misc";
+export * as notations from "./notations";
 export * as protobuf from "./protobuf";
 export * as tags from "./tags";
 
@@ -17,9 +18,13 @@ export * from "./schemas/json/IJsonComponents";
 export * from "./schemas/json/IJsonSchema";
 export * from "./IRandomGenerator";
 export * from "./IValidation";
+export * from "./TypeGuardError";
+
 export * from "./Primitive";
 export * from "./Resolved";
-export * from "./TypeGuardError";
+export * from "./CamelCase";
+export * from "./PascalCase";
+export * from "./SnakeCase";
 
 /* -----------------------------------------------------------
     BASIC VALIDATORS