💫 workflow(3-4):

Author: 2495867729

README.md

@@ -29,4 +29,8 @@
       - /medium/119
       - /medium/296 *
       - /medium/298 *
-      - /medium/459 *
+      - /medium/459 *
+      - /medium/529 
+      - /medium/531 *
+      - /medium/599 *
+      - /medium/610 *

medium/529-Absolute.ts

@@ -0,0 +1,16 @@
+/*
+ * @Date: 2022-03-04
+ * @Description: Absolute
+ */
+
+type Test = "-100";
+type Test2 = -100;
+
+type Absolute<T extends string | number | bigint> = `${T}` extends `-${infer F}`
+    ? F
+    : T;
+
+type Result = Absolute<Test>; // expected to be "100"
+type Result2 = Absolute<Test2>; // expected to be "100"
+
+export {};

medium/531-StringToUnion.ts

@@ -0,0 +1,18 @@
+/*
+ * @Date: 2022-03-04
+ * @Description: String to Union
+ */
+
+type Test = "123";
+type Test2 = "1";
+
+type StringToUnion<T extends string> = T extends ""
+    ? never
+    : T extends `${infer F}${infer R}`
+    ? F | StringToUnion<R>
+    : T;
+
+type Result = StringToUnion<Test>; // expected to be "1" | "2" | "3"
+type Result2 = StringToUnion<Test2>; // expected to be "1"
+
+export {};

medium/599-Merge.ts

@@ -0,0 +1,41 @@
+/*
+ * @Date: 2022-03-04
+ * @Description: Merge
+ */
+
+/**
+ * Merge two types into a new type. Keys of the second type
+ * overrides keys of the first type.
+ */
+
+type Test1 = {
+    name: string;
+    age: 1;
+};
+
+type Test2 = {
+    name: number;
+    age: number;
+    class: string;
+};
+
+//type Merge<T, K> = {
+//    //[P in keyof T | keyof K]: P extends keyof K ? K[P] : never;
+//    [P in keyof K]: K[P];
+//} & {
+//    [X in Exclude<keyof T, keyof K>]: T[X];
+//};
+type Merge<
+    T extends Record<string, unknown>,
+    K extends Record<string, unknown>
+> = {
+    [P in keyof T | keyof K]: P extends keyof K
+        ? K[P]
+        : P extends keyof T
+        ? T[P]
+        : never;
+};
+
+type Result = Merge<Test1, Test2>; // expected to be {name:number,age:number}
+
+export {};

medium/610-CamelCase.ts

@@ -0,0 +1,87 @@
+/*
+ * @Date: 2022-03-04
+ * @Description: CamelCase
+ */
+
+//for-bar-baz -> forBarBaz
+const characterMap = {
+    a: "A",
+    b: "B",
+    c: "C",
+    d: "D",
+    e: "E",
+    f: "F",
+    g: "G",
+    h: "H",
+    i: "I",
+    j: "J",
+    k: "K",
+    l: "L",
+    m: "M",
+    n: "N",
+    o: "O",
+    p: "P",
+    q: "Q",
+    r: "R",
+    s: "S",
+    t: "T",
+    u: "U",
+    v: "V",
+    w: "W",
+    x: "X",
+    y: "Y",
+    z: "Z",
+} as const;
+
+type characterType = typeof characterMap;
+
+type Test = "for-bar-baz";
+type Test2 = "ar-baz";
+type Test3 = "baz";
+
+type transform<T extends string> = T extends keyof characterType
+    ? characterType[T]
+    : T;
+type MyCapitalize<T extends string> = T extends `${infer R}${infer U}`
+    ? `${transform<R>}${U}`
+    : never;
+
+type CamelCase<T extends string> = T extends `${infer F}-${infer R}`
+    ? CamelCase<`${F}${MyCapitalize<R>}`>
+    : T;
+
+type Result = CamelCase<Test>; //expected to be 'FooBarBaz'
+
+type Result2 = CamelCase<Test2>; //expected to be 'arBaz'
+type Result3 = CamelCase<Test3>; //expected to be 'baz'
+
+export {};
+
+/** https://github.com/type-challenges/type-challenges/issues/6269
+ * type CamelCase<S extends string> = 
+  S extends "" 
+  ? 
+  "" 
+  :
+  S extends `${infer A}${infer B}` 
+    ? 
+    A extends '-' 
+      ?
+      B extends `${infer C}${infer D}`
+        ?
+        C extends Uppercase<C> 
+          ?
+          `${A}${CamelCase<B>}`
+          :
+          `${Uppercase<C>}${CamelCase<D>}`
+        :
+        B extends Uppercase<B>
+          ?
+          `-${B}`
+          :
+          `${Uppercase<B>}`
+      :
+      `${A}${CamelCase<B>}`
+    :
+    S
+ */