typescript-builtins-extended 0.0.1 → 0.1.0

package/README.en.md

@@ -0,0 +1,31 @@
+# Typescript Utilities
+
+English | [简体中文](README.md)
+
+`typescript-builtins-extended` does not provide any js code and focuses on typescript type deduction.
+
+## Usage
+
+There are two ways to use it, module introduction and global introduction.
+
+### Module introduction
+
+```typescript
+import { Prettify } from 'typescript-builtins-extended'
+
+type A = Prettify<{ a: number } & { b: string }>
+```
+
+### Global introduction
+
+Add the following code to a global declaration file, such as `global.d.ts`.
+
+```typescript
+/// <reference types="typescript-builtins-extended/global" />
+```
+
+You can then use `typescript-builtins-extended` just like the built-in utility types.
+
+```typescript
+type A = Prettify<{ a: number } & { b: string }>
+```

package/README.md

@@ -1,15 +1,31 @@
 # Typescript Utilities
 
-English | [简体中文](README.zh-CN.md)
+[English](README.en.md) | 简体中文
 
-Provides a globally-scoped type conversion tool for typescript. Unlike other tools, `typescript-builtins-extended` does not provide any js code and focuses on typescript type conversion. And it can be used directly like using built-in utility types such as `Omit` `Pick` without additional import.
+`typescript-builtins-extended` 不提供任何 js 代码，专注于 typescript 的类型推导。
 
-Utility types and implementation methods come from [type-challenges](https://github.com/type-challenges/type-challenges.git)
+## 使用方式
 
-## Usage
+有两种使用方式，模块引入和全局引入。
 
-Add the following code to the `d.ts` declaration file
+### 模块引入
 
-```ts
-/// <reference types="typescript-builtins-extended" />
+```typescript
+import type { Prettify } from 'typescript-builtins-extended'
+
+type A = Prettify<{ a: number } & { b: string }>
+```
+
+### 全局引入
+
+将下面的代码添加到全局声明文件中，例如 `global.d.ts`。
+
+```typescript
+/// <reference types="typescript-builtins-extended/global" />
+```
+
+然后就可以像使用内置实用程序类型一样使用 `typescript-builtins-extended` 了。
+
+```typescript
+type A = Prettify<{ a: number } & { b: string }>
 ```

package/global.d.ts

@@ -0,0 +1,205 @@
+type Whitespace = " " | "\n" | "\t";
+export {};
+declare global {
+    /**
+     * 判断两个类型是否相等
+     */
+    type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+    /**
+     * 判断两个类型是否不相等
+     */
+    type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;
+    /**
+     * 判断类型是否为 any
+     */
+    type IsAny<T> = 0 extends 1 & T ? true : false;
+    /**
+     * 判断类型是否不为 any
+     */
+    type NotAny<T> = true extends IsAny<T> ? false : true;
+    /**
+     * 将类型 T 格式化输出，显示为单一对象类型
+     */
+    type Prettify<T> = {
+        [K in keyof T]: T[K];
+    } & {};
+    /**
+     * Prettify 的别名，用于测试类型结果
+     */
+    type Debug<T> = {
+        [K in keyof T]: T[K];
+    };
+    /**
+     * 根据条件 C 判断返回类型 T 或 F
+     */
+    type If<C extends boolean, T, F> = C extends true ? T : F;
+    /**
+     * 从字符串中移除前面的 空格 或 指定的字符
+     */
+    type TrimStart<S extends string, Chars extends string = Whitespace> = S extends `${Chars}${infer R}` ? TrimStart<R> : S;
+    /**
+     * 从字符串中移除后面的 空格 或 指定的字符
+     */
+    type TrimEnd<S extends string, Chars extends string = Whitespace> = S extends `${infer L}${Chars}` ? TrimEnd<L> : S;
+    /**
+     * 从字符串中移除前面和后面的 空格 或 指定的字符
+     */
+    type Trim<S extends string, Chars extends string = Whitespace> = TrimStart<TrimEnd<S, Chars>, Chars>;
+    /**
+     * 检查字符串 S 是否以 Target 开头
+     */
+    type StartsWith<S extends string, Target extends string> = S extends `${Target}${infer _}` ? true : false;
+    /**
+     * 检查字符串 S 是否以 Target 结束
+     */
+    type EndsWith<S extends string, Target extends string> = S extends `${infer _}${Target}` ? true : false;
+    /**
+     * 根据 SEP 拆分字符串
+     */
+    type Split<S extends string, SEP extends string = never> = [
+        SEP
+    ] extends [
+        never
+    ] ? [
+        S
+    ] : string extends SEP ? string[] : string extends S ? string[] : S extends `${infer First}${SEP}${infer Rest}` ? Rest extends "" ? [
+        First
+    ] : [
+        First,
+        ...Split<Rest, SEP>
+    ] : S extends SEP ? [
+    ] : [
+        S
+    ];
+    /**
+     * 替换 S 字符串中匹配的 Pattern 为给定的 Replacement
+     */
+    type Replace<S extends string, Pattern extends string, Repalcement extends string> = Pattern extends "" ? S : S extends `${infer F}${Pattern}${infer R}` ? `${F}${Repalcement}${R}` : S;
+    /**
+     * 替换 S 字符串中所有匹配的 Pattern 为给定的 Replacement
+     */
+    type ReplaceAll<S extends string, Pattern extends string, Repalcement extends string> = Pattern extends "" ? S : S extends `${infer F}${Pattern}${infer R}` ? `${F}${Repalcement}${ReplaceAll<R, Pattern, Repalcement>}` : S;
+    /**
+     * 返回数据第一个元素的类型。
+     */
+    type First<T extends any[]> = T extends [
+    ] ? never : T[0];
+    /**
+     * 返回数组最后一个元素的类型。
+     */
+    type Last<T extends any[]> = T extends [
+        ...infer _,
+        infer L
+    ] ? L : never;
+    /**
+     * 返回数组的前 N-1 项（N 为数组T的长度）以相同的顺序组成的数组。
+     */
+    type Pop<T extends any[]> = T extends [
+    ] ? [
+    ] : T extends [
+        ...infer R,
+        infer _
+    ] ? R : never;
+    /**
+     * 将数组 T 递归为一维数组
+     */
+    type Flatten<T extends any[]> = T extends [
+        infer FIRST,
+        ...infer REST
+    ] ? FIRST extends any[] ? [
+        ...Flatten<FIRST>,
+        ...Flatten<REST>
+    ] : [
+        FIRST,
+        ...Flatten<REST>
+    ] : [
+    ];
+    /**
+     * 将数组 T 与数组 U 合并为一个新数组
+     */
+    type Concat<T extends readonly any[], U extends readonly any[]> = [
+        ...T,
+        ...U
+    ];
+    /**
+     * 判断数组 T 是否包含元素 U
+     */
+    type Includes<T extends readonly any[], U> = T extends [
+        infer F,
+        ...infer R
+    ] ? Equal<F, U> extends true ? true : Includes<R, U> : false;
+    /**
+     * 判断类型 T 是否为字面量对象
+     */
+    type IsPlainObject<T> = T extends (...args: any) => any ? false : T extends Record<PropertyKey, any> ? Extract<keyof T, symbol> extends infer U ? [
+        U
+    ] extends [
+        never
+    ] ? true : false : never : false;
+    /**
+     * 获取类型 T 只读属性的键名
+     */
+    type ReadonlyKeys<T> = {
+        [K in keyof T]-?: Equal<{
+            readonly [P in K]: T[K];
+        }, {
+            [P in K]: T[K];
+        }> extends true ? K : never;
+    }[keyof T];
+    /**
+     * 获取类型 T 必填属性的键名
+     */
+    type RequiredKeys<T> = {
+        [K in keyof T]-?: {} extends {
+            [P in K]: T[K];
+        } ? never : K;
+    }[keyof T];
+    /**
+     * 获取类型 T 可选属性的键名
+     */
+    type OptionalKeys<T> = {
+        [K in keyof T]-?: {} extends {
+            [P in K]: T[K];
+        } ? K : never;
+    }[keyof T];
+    /**
+     * 获取类型 T 的只读属性
+     */
+    type GetReadonly<T> = {
+        [K in ReadonlyKeys<T>]: T[K];
+    };
+    /**
+     * 获取类型 T 的必填属性
+     */
+    type GetRequired<T> = {
+        [K in keyof T as T[K] extends Required<T>[K] ? K : never]: T[K];
+    };
+    /**
+     * 获取类型 T 的可选属性
+     */
+    type GetOptional<T> = {
+        [K in keyof T as T[K] extends Required<T>[K] ? never : K]: T[K];
+    };
+    /**
+     * 深度转换类型 T 的属性为只读
+     */
+    type DeepReadonly<T> = {
+        readonly [K in keyof T]: keyof T[K] extends never ? T[K] : DeepReadonly<T[K]>;
+    };
+    /**
+     * 深度转化类型 T 的属性为必填
+     */
+    type DeepRequired<T> = {
+        [K in keyof T]-?: keyof T[K] extends never ? T[K] : DeepRequired<T[K]>;
+    };
+    /**
+     * 深度转化类型 T 的属性为可选
+     */
+    type DeepOptional<T> = {
+        [K in keyof T]?: keyof T[K] extends never ? T[K] : DeepOptional<T[K]>;
+    };
+    /**
+     * 根据对象 T 的 路径 K 获取值，如果解析 value 是 undefined 会以 defaultValue 取代。
+     */
+    type GetValue<T, K extends string, Default = never> = K extends keyof T ? T[K] : K extends `${infer F}.${infer R}` ? F extends keyof T ? GetValue<T[F], R> : Default : Default;
+}

package/index.d.ts

@@ -1,27 +1,204 @@
-export { }
+/**
+ * 判断两个类型是否相等
+ */
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+/**
+ * 判断两个类型是否不相等
+ */
+export type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true;
+/**
+ * 判断类型是否为 any
+ */
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * 判断类型是否不为 any
+ */
+export type NotAny<T> = true extends IsAny<T> ? false : true;
+/**
+ * 将类型 T 格式化输出，显示为单一对象类型
+ */
+export type Prettify<T> = {
+	[K in keyof T]: T[K];
+} & {};
+/**
+ * Prettify 的别名，用于测试类型结果
+ */
+export type Debug<T> = {
+	[K in keyof T]: T[K];
+};
+/**
+ * 根据条件 C 判断返回类型 T 或 F
+ */
+export type If<C extends boolean, T, F> = C extends true ? T : F;
+type Whitespace = " " | "\n" | "\t";
+/**
+ * 从字符串中移除前面的 空格 或 指定的字符
+ */
+export type TrimStart<S extends string, Chars extends string = Whitespace> = S extends `${Chars}${infer R}` ? TrimStart<R> : S;
+/**
+ * 从字符串中移除后面的 空格 或 指定的字符
+ */
+export type TrimEnd<S extends string, Chars extends string = Whitespace> = S extends `${infer L}${Chars}` ? TrimEnd<L> : S;
+/**
+ * 从字符串中移除前面和后面的 空格 或 指定的字符
+ */
+export type Trim<S extends string, Chars extends string = Whitespace> = TrimStart<TrimEnd<S, Chars>, Chars>;
+/**
+ * 检查字符串 S 是否以 Target 开头
+ */
+export type StartsWith<S extends string, Target extends string> = S extends `${Target}${infer _}` ? true : false;
+/**
+ * 检查字符串 S 是否以 Target 结束
+ */
+export type EndsWith<S extends string, Target extends string> = S extends `${infer _}${Target}` ? true : false;
+/**
+ * 根据 SEP 拆分字符串
+ */
+export type Split<S extends string, SEP extends string = never> = [
+	SEP
+] extends [
+	never
+] ? [
+	S
+] : string extends SEP ? string[] : string extends S ? string[] : S extends `${infer First}${SEP}${infer Rest}` ? Rest extends "" ? [
+	First
+] : [
+	First,
+	...Split<Rest, SEP>
+] : S extends SEP ? [
+] : [
+	S
+];
+/**
+ * 替换 S 字符串中匹配的 Pattern 为给定的 Replacement
+ */
+export type Replace<S extends string, Pattern extends string, Repalcement extends string> = Pattern extends "" ? S : S extends `${infer F}${Pattern}${infer R}` ? `${F}${Repalcement}${R}` : S;
+/**
+ * 替换 S 字符串中所有匹配的 Pattern 为给定的 Replacement
+ */
+export type ReplaceAll<S extends string, Pattern extends string, Repalcement extends string> = Pattern extends "" ? S : S extends `${infer F}${Pattern}${infer R}` ? `${F}${Repalcement}${ReplaceAll<R, Pattern, Repalcement>}` : S;
+/**
+ * 返回数据第一个元素的类型。
+ */
+export type First<T extends any[]> = T extends [
+] ? never : T[0];
+/**
+ * 返回数组最后一个元素的类型。
+ */
+export type Last<T extends any[]> = T extends [
+	...infer _,
+	infer L
+] ? L : never;
+/**
+ * 返回数组的前 N-1 项（N 为数组T的长度）以相同的顺序组成的数组。
+ */
+export type Pop<T extends any[]> = T extends [
+] ? [
+] : T extends [
+	...infer R,
+	infer _
+] ? R : never;
+/**
+ * 将数组 T 递归为一维数组
+ */
+export type Flatten<T extends any[]> = T extends [
+	infer FIRST,
+	...infer REST
+] ? FIRST extends any[] ? [
+	...Flatten<FIRST>,
+	...Flatten<REST>
+] : [
+	FIRST,
+	...Flatten<REST>
+] : [
+];
+/**
+ * 将数组 T 与数组 U 合并为一个新数组
+ */
+export type Concat<T extends readonly any[], U extends readonly any[]> = [
+	...T,
+	...U
+];
+/**
+ * 判断数组 T 是否包含元素 U
+ */
+export type Includes<T extends readonly any[], U> = T extends [
+	infer F,
+	...infer R
+] ? Equal<F, U> extends true ? true : Includes<R, U> : false;
+/**
+ * 判断类型 T 是否为字面量对象
+ */
+export type IsPlainObject<T> = T extends (...args: any) => any ? false : T extends Record<PropertyKey, any> ? Extract<keyof T, symbol> extends infer U ? [
+	U
+] extends [
+	never
+] ? true : false : never : false;
+/**
+ * 获取类型 T 只读属性的键名
+ */
+export type ReadonlyKeys<T> = {
+	[K in keyof T]-?: Equal<{
+		readonly [P in K]: T[K];
+	}, {
+		[P in K]: T[K];
+	}> extends true ? K : never;
+}[keyof T];
+/**
+ * 获取类型 T 必填属性的键名
+ */
+export type RequiredKeys<T> = {
+	[K in keyof T]-?: {} extends {
+		[P in K]: T[K];
+	} ? never : K;
+}[keyof T];
+/**
+ * 获取类型 T 可选属性的键名
+ */
+export type OptionalKeys<T> = {
+	[K in keyof T]-?: {} extends {
+		[P in K]: T[K];
+	} ? K : never;
+}[keyof T];
+/**
+ * 获取类型 T 的只读属性
+ */
+export type GetReadonly<T> = {
+	[K in ReadonlyKeys<T>]: T[K];
+};
+/**
+ * 获取类型 T 的必填属性
+ */
+export type GetRequired<T> = {
+	[K in keyof T as T[K] extends Required<T>[K] ? K : never]: T[K];
+};
+/**
+ * 获取类型 T 的可选属性
+ */
+export type GetOptional<T> = {
+	[K in keyof T as T[K] extends Required<T>[K] ? never : K]: T[K];
+};
+/**
+ * 深度转换类型 T 的属性为只读
+ */
+export type DeepReadonly<T> = {
+	readonly [K in keyof T]: keyof T[K] extends never ? T[K] : DeepReadonly<T[K]>;
+};
+/**
+ * 深度转化类型 T 的属性为必填
+ */
+export type DeepRequired<T> = {
+	[K in keyof T]-?: keyof T[K] extends never ? T[K] : DeepRequired<T[K]>;
+};
+/**
+ * 深度转化类型 T 的属性为可选
+ */
+export type DeepOptional<T> = {
+	[K in keyof T]?: keyof T[K] extends never ? T[K] : DeepOptional<T[K]>;
+};
+/**
+ * 根据对象 T 的 路径 K 获取值，如果解析 value 是 undefined 会以 defaultValue 取代。
+ */
+export type GetValue<T, K extends string, Default = never> = K extends keyof T ? T[K] : K extends `${infer F}.${infer R}` ? F extends keyof T ? GetValue<T[F], R> : Default : Default;
 
-declare global {
-  export type { GetReadonlyKeys } from './src/00005-extreme-readonly-keys'
-  import('./src/00005-extreme-readonly-keys')
-
-  export type { DeepReadonly } from './src/00009-medium-deep-readonly'
-  import('./src/00009-medium-deep-readonly')
-
-  export type { TupleToUnion } from './src/00010-medium-tuple-to-union'
-  import('./src/00010-medium-tuple-to-union')
-
-  export type { TupleToObject } from './src/00011-easy-tuple-to-object'
-  import('./src/00011-easy-tuple-to-object')
-
-  export type { First } from './src/00014-easy-first'
-  import('./src/00014-easy-first')
-
-  export type { Last } from './src/00015-medium-last'
-  import('./src/00015-medium-last')
-
-  export type { Pop } from './src/00016-medium-pop'
-  import('./src/00016-medium-pop')
-
-  export type { UnionToTuple } from './src/00730-hard-union-to-tuple'
-  import('./src/00730-hard-union-to-tuple')
-}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typescript-builtins-extended",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Collection of TypeScript Utility Types.",
   "keywords": [
     "typescript",
@@ -16,16 +16,28 @@
     "url": "https://github.com/hayden-fr/typescript-builtins-extended.git"
   },
   "files": [
-    "src",
     "index.d.ts",
+    "global.d.ts",
     "tsconfig.json"
   ],
   "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts"
+    },
+    "./global": {
+      "types": "./global.d.ts"
+    }
+  },
   "author": "hayden <hayden.mike.zhang@gmail.com>",
   "devDependencies": {
     "typescript": "^5.9.2"
   },
   "scripts": {
+    "build": "pnpm run build:dts && pnpm run build:global-dts && pnpm run build:format",
+    "build:dts": "pnpx dts-bundle-generator --config ./build.json",
+    "build:global-dts": "node scripts/generate-global-dts.mjs",
+    "build:format": "pnpx prettier --write index.d.ts global.d.ts",
     "test": "tsc --noEmit"
   }
 }

package/tsconfig.json

@@ -13,7 +13,7 @@
     //  - `CommonJS` is too outdated
     //  - the ecosystem hasn't fully caught up with `Node16`/`NodeNext`
     // This recommendation includes environments like Vitest, Vite Config File, Vite SSR, etc.
-    "module": "ESNext",
+    "module": "esnext",
 
     // We expect users to use bundlers.
     // So here we enable some resolution features that are only available in bundlers.
@@ -24,6 +24,8 @@
     // It helps to avoid mysterious errors such as `Cannot redeclare block-scoped variable 'name`.
     // https://www.totaltypescript.com/cannot-redeclare-block-scoped-variable#solution-3-your-module-isnt-a-module
     "moduleDetection": "force",
+    "declaration": true,
+    "emitDeclarationOnly": true,
 
     // `"noImplicitThis": true` is part of `strict`
     // Added again here in case some users decide to disable `strict`.
@@ -32,9 +34,8 @@
     "strict": true,
 
     // supports ES2016+
-    "target": "ESNext",
+    "target": "esnext",
 
-    // Recommended
-    "skipLibCheck": true,
+    "newLine": "lf"
   }
 }

package/README.zh-CN.md

@@ -1,15 +0,0 @@
-# Typescript Utilities
-
-[English](README.md) | 简体中文
-
-为 typescript 提供全局范围的类型转换工具，与其他工具不同，`typescript-builtins-extended` 不提供任何 js 代码，专注于 typescript 的类型转换。并且可以像使用 `Omit` `Pick` 等内置实用程序类型一样直接使用，无需额外导入。
-
-实用程序类型与其实现方式来源于 [type-challenges](https://github.com/type-challenges/type-challenges.git)
-
-## 使用
-
-将下面的代码添加到 `d.ts` 声明文件中
-
-```ts
-/// <reference types="typescript-builtins-extended" />
-```

package/src/00005-extreme-readonly-keys.ts

@@ -1,34 +0,0 @@
-// ============= Test Cases =============
-import type { Equal, Expect } from './test-utils'
-
-type cases = [
-  Expect<Equal<'title', GetReadonlyKeys<Todo1>>>,
-  Expect<Equal<'title' | 'description', GetReadonlyKeys<Todo2>>>,
-]
-
-interface Todo1 {
-  readonly title: string
-  description: string
-  completed: boolean
-}
-
-interface Todo2 {
-  readonly title: string
-  readonly description: string
-  completed?: boolean
-}
-
-
-// ============= Your Code Here =============
-// Implemented by https://github.com/type-challenges/type-challenges/issues/139
-
-/**
- * Implement a generic `GetReadonlyKeys<T>` that returns a union of the readonly keys of an Object.
- *
- * 实现泛型 `GetReadonlyKeys<T>`，`GetReadonlyKeys<T>` 返回由对象 T 所有只读属性的键组成的联合类型。
- */
-export type GetReadonlyKeys<
-  T,
-  U extends Readonly<T> = Readonly<T>,
-  K extends keyof T = keyof T
-> = K extends keyof T ? Equal<Pick<T, K>, Pick<U, K>> extends true ? K : never : never;

package/src/00009-medium-deep-readonly.ts

@@ -1,69 +0,0 @@
-// ============= Test Cases =============
-import type { Equal, Expect } from './test-utils'
-
-type cases = [
-  Expect<Equal<DeepReadonly<X1>, Expected1>>,
-  Expect<Equal<DeepReadonly<X2>, Expected2>>,
-]
-
-type X1 = {
-  a: () => 22
-  b: string
-  c: {
-    d: boolean
-    e: {
-      g: {
-        h: {
-          i: true
-          j: 'string'
-        }
-        k: 'hello'
-      }
-      l: [
-        'hi',
-        {
-          m: ['hey']
-        },
-      ]
-    }
-  }
-}
-
-type X2 = { a: string } | { b: number }
-
-type Expected1 = {
-  readonly a: () => 22
-  readonly b: string
-  readonly c: {
-    readonly d: boolean
-    readonly e: {
-      readonly g: {
-        readonly h: {
-          readonly i: true
-          readonly j: 'string'
-        }
-        readonly k: 'hello'
-      }
-      readonly l: readonly [
-        'hi',
-        {
-          readonly m: readonly ['hey']
-        },
-      ]
-    }
-  }
-}
-
-type Expected2 = { readonly a: string } | { readonly b: number }
-
-// ============= Your Code Here =============
-// Implemented by https://github.com/type-challenges/type-challenges/issues/13716
-
-/**
- * Implement a generic `DeepReadonly<T>` which make every parameter of an object - and its sub-objects recursively - readonly.
- *
- * 实现一个泛型 `DeepReadonly<T>`，它将对象的每个参数及其子对象递归地设为只读。
- */
-export type DeepReadonly<T> = {
-  readonly [P in keyof T]: keyof T[P] extends never ? T[P] : DeepReadonly<T[P]>
-}

package/src/00010-medium-tuple-to-union.ts

@@ -1,18 +0,0 @@
-// ============= Test Cases =============
-import type { Equal, Expect } from './test-utils'
-
-type cases = [
-  Expect<Equal<TupleToUnion<[123, '456', true]>, 123 | '456' | true>>,
-  Expect<Equal<TupleToUnion<[123]>, 123>>,
-]
-
-
-// ============= Your Code Here =============
-// Implemented by https://github.com/type-challenges/type-challenges/issues/7
-
-/**
- * Implement a generic `TupleToUnion<T>` which covers the values of a tuple to its values union.
- *
- * 实现泛型 `TupleToUnion<T>`，它返回元组所有值的合集。
- */
-export type TupleToUnion<T> = T extends Array<infer ITEMS> ? ITEMS : never

package/src/00011-easy-tuple-to-object.ts

@@ -1,32 +0,0 @@
-// ============= Test Cases =============
-import type { Equal, Expect } from './test-utils'
-
-const tuple = ['tesla', 'model 3', 'model X', 'model Y'] as const
-const tupleNumber = [1, 2, 3, 4] as const
-const sym1 = Symbol(1)
-const sym2 = Symbol(2)
-const tupleSymbol = [sym1, sym2] as const
-const tupleMix = [1, '2', 3, '4', sym1] as const
-
-type cases = [
-  Expect<Equal<TupleToObject<typeof tuple>, { 'tesla': 'tesla', 'model 3': 'model 3', 'model X': 'model X', 'model Y': 'model Y' }>>,
-  Expect<Equal<TupleToObject<typeof tupleNumber>, { 1: 1, 2: 2, 3: 3, 4: 4 }>>,
-  Expect<Equal<TupleToObject<typeof tupleSymbol>, { [sym1]: typeof sym1, [sym2]: typeof sym2 }>>,
-  Expect<Equal<TupleToObject<typeof tupleMix>, { 1: 1, '2': '2', 3: 3, '4': '4', [sym1]: typeof sym1 }>>,
-]
-
-// @ts-expect-error
-type error = TupleToObject<[[1, 2], {}]>
-
-
-// ============= Your Code Here =============
-// Implemented by https://github.com/type-challenges/type-challenges/issues/5896
-
-/**
- * Given an array, transform it into an object type and the key/value must be in the provided array.
- *
- * 将一个元组类型转换为对象类型，这个对象类型的键/值和元组中的元素对应。
- */
-export type TupleToObject<T extends readonly (string | symbol | number)[]> = {
-  [P in T[number]]: P
-}

package/src/00014-easy-first.ts

@@ -1,27 +0,0 @@
-// ============= Test Cases =============
-import type { Equal, Expect } from './test-utils'
-
-type cases = [
-  Expect<Equal<First<[3, 2, 1]>, 3>>,
-  Expect<Equal<First<[() => 123, { a: string }]>, () => 123>>,
-  Expect<Equal<First<[]>, never>>,
-  Expect<Equal<First<[undefined]>, undefined>>,
-]
-
-type errors = [
-  // @ts-expect-error
-  First<'notArray'>,
-  // @ts-expect-error
-  First<{ 0: 'arrayLike' }>,
-]
-
-
-// ============= Your Code Here =============
-// Implemented by https://github.com/type-challenges/type-challenges/issues/16315
-
-/**
- * Implement a generic `First<T>` that takes an Array T and returns its first element's type.
- *
- * 实现一个 `First<T>` 泛型，它接受一个数组T并返回它的第一个元素的类型。
- */
-export type First<T extends any[]> = T extends [] ? never : T[0]

package/src/00015-medium-last.ts

@@ -1,20 +0,0 @@
-// ============= Test Cases =============
-import type { Equal, Expect } from './test-utils'
-
-type cases = [
-  Expect<Equal<Last<[]>, never>>,
-  Expect<Equal<Last<[2]>, 2>>,
-  Expect<Equal<Last<[3, 2, 1]>, 1>>,
-  Expect<Equal<Last<[() => 123, { a: string }]>, { a: string }>>,
-]
-
-
-// ============= Your Code Here =============
-// Implemented by https://github.com/type-challenges/type-challenges/issues/38
-
-/**
- * Implement a generic `Last<T>` that takes an Array T and returns its last element.
- *
- * 实现一个 `Last<T>` 泛型，它接受一个数组T并返回其最后一个元素的类型。
- */
-export type Last<T extends any[]> = T extends [...infer _, infer L] ? L : never

package/src/00016-medium-pop.ts

@@ -1,22 +0,0 @@
-// ============= Test Cases =============
-import type { Equal, Expect } from './test-utils'
-
-type cases = [
-  Expect<Equal<Pop<[3, 2, 1]>, [3, 2]>>,
-  Expect<Equal<Pop<['a', 'b', 'c', 'd']>, ['a', 'b', 'c']>>,
-  Expect<Equal<Pop<[]>, []>>,
-]
-
-// ============= Your Code Here =============
-// Implemented by https://github.com/type-challenges/type-challenges/issues/37295
-
-/**
- * Implement a generic `Pop<T>` that takes an Array T and returns an Array without it's last element.
- *
- * 实现一个泛型 `Pop<T>`，它接受一个数组T，并返回一个由数组T的前 N-1 项（N 为数组T的长度）以相同的顺序组成的数组。
- */
-export type Pop<T extends any[]> = T extends []
-  ? []
-  : T extends [...infer R, infer _]
-  ? R
-  : never

package/src/00730-hard-union-to-tuple.ts

@@ -1,52 +0,0 @@
-// ============= Test Cases =============
-import type { Equal, Expect } from './test-utils'
-
-type ExtractValuesOfTuple<T extends any[]> = T[keyof T & number]
-
-type cases = [
-  Expect<Equal<UnionToTuple<'a' | 'b'>['length'], 2>>,
-  Expect<Equal<ExtractValuesOfTuple<UnionToTuple<'a' | 'b'>>, 'a' | 'b'>>,
-  Expect<Equal<ExtractValuesOfTuple<UnionToTuple<'a'>>, 'a'>>,
-  Expect<Equal<ExtractValuesOfTuple<UnionToTuple<any>>, any>>,
-  Expect<Equal<ExtractValuesOfTuple<UnionToTuple<undefined | void | 1>>, void | 1>>,
-  Expect<Equal<ExtractValuesOfTuple<UnionToTuple<any | 1>>, any | 1>>,
-  Expect<Equal<ExtractValuesOfTuple<UnionToTuple<any | 1>>, any>>,
-  Expect<Equal<ExtractValuesOfTuple<UnionToTuple<'d' | 'f' | 1 | never>>, 'f' | 'd' | 1>>,
-  Expect<Equal<ExtractValuesOfTuple<UnionToTuple<[{ a: 1 }] | 1>>, [{ a: 1 }] | 1>>,
-  Expect<Equal<ExtractValuesOfTuple<UnionToTuple<never>>, never>>,
-  Expect<Equal<ExtractValuesOfTuple<UnionToTuple<'a' | 'b' | 'c' | 1 | 2 | 'd' | 'e' | 'f' | 'g'>>, 'f' | 'e' | 1 | 2 | 'g' | 'c' | 'd' | 'a' | 'b'>>,
-]
-
-
-// ============= Your Code Here =============
-// Implemented by https://github.com/type-challenges/type-challenges/issues/737
-
-/**
- * UnionToIntersection<{ foo: string } | { bar: string }> =
- *  { foo: string } & { bar: string }.
- */
-type UnionToIntersection<U> = (
-  U extends unknown ? (arg: U) => 0 : never
-) extends (arg: infer I) => 0
-  ? I
-  : never;
-
-/**
- * LastInUnion<1 | 2> = 2.
- */
-type LastInUnion<U> = UnionToIntersection<
-  U extends unknown ? (x: U) => 0 : never
-> extends (x: infer L) => 0
-  ? L
-  : never;
-
-/**
- * Implement a type, UnionToTuple, that converts a union to a tuple.
- *
- * 将联合转换为元组的类型。
- *
- * UnionToTuple<1 | 2> = [1, 2].
- */
-export type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never]
-  ? []
-  : [...UnionToTuple<Exclude<U, Last>>, Last];

package/src/test-utils.ts

@@ -1,31 +0,0 @@
-export type Expect<T extends true> = T
-export type ExpectTrue<T extends true> = T
-export type ExpectFalse<T extends false> = T
-export type IsTrue<T extends true> = T
-export type IsFalse<T extends false> = T
-
-export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
-  ? true
-  : false
-export type NotEqual<X, Y> = true extends Equal<X, Y> ? false : true
-
-// https://stackoverflow.com/questions/49927523/disallow-call-with-any/49928360#49928360
-export type IsAny<T> = 0 extends 1 & T ? true : false
-export type NotAny<T> = true extends IsAny<T> ? false : true
-
-export type Debug<T> = { [K in keyof T]: T[K] }
-export type MergeInsertions<T> = T extends object ? { [K in keyof T]: MergeInsertions<T[K]> } : T
-
-export type Alike<X, Y> = Equal<MergeInsertions<X>, MergeInsertions<Y>>
-
-export type ExpectExtends<VALUE, EXPECTED> = EXPECTED extends VALUE ? true : false
-export type ExpectValidArgs<
-  FUNC extends (...args: any[]) => any,
-  ARGS extends any[]
-> = ARGS extends Parameters<FUNC> ? true : false
-
-export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
-  k: infer I
-) => void
-  ? I
-  : never