@kakasoo/deep-strict-types 1.0.25 → 1.0.26

package/README.md

@@ -1,4 +1,5 @@
 # How To Use
+
 ![example](https://github.com/user-attachments/assets/28316425-8302-453e-b238-0c732606e6a7)
 
 ```bash
@@ -7,11 +8,13 @@ npm i @kakasoo/deep-strict-types
 
 # DeepStrictTypes
 
-**DeepStrictTypes** extends TypeScript utility types, enabling safe operations like `Omit` and `Pick` on nested objects or arrays by specifying the keys to be inferred. This allows for more strict and accurate type checks. **Now, you don't have to recombine numerous types daily to remove a single key from a nested object. You can quickly omit and pick the internal keys you want!**
+**DeepStrictTypes** extends TypeScript utility types, enabling safe operations like `Omit` and `Pick` on deeply nested objects or arrays by specifying keys to be inferred. It provides strict and accurate type checks, simplifying tasks like removing a single key from a nested object without recombining multiple types. Quickly and precisely omit or pick the internal keys you need!
+
+## Key Features
 
-## DeepStrictObjectKeys
+### `DeepStrictObjectKeys`
 
-`DeepStrictObjectKeys<T>` extracts all nested keys from an object `T`, preserving the structure of the nested object and returning the types of the keys. This is useful when you need to handle specific keys safely at deeper levels of an object.
+Extract all nested keys from an object `T`, preserving its structure. Useful for safely handling specific keys at deeper levels of an object.
 
 ```typescript
 type Example = {
@@ -28,13 +31,13 @@ type Example = {
 type Keys = DeepStrictObjectKeys<Example>;
 ```
 
-In the case of an array, the inside is represented by the `[*]` symbol. Of course, the arrangement of the array, the arrangement of objects in the array, and even if the top object is an array, it is perfectly inferred.
+In arrays, elements are represented with the `[*]` symbol, ensuring perfect inference even for nested structures.
 
-## DeepStrictOmit
+### `DeepStrictOmit`
 
-`DeepStrictOmit<T, K>` creates a new type by excluding properties corresponding to the key K from object T, while preserving the nested structure. This type allows precise omission of keys even in deeply nested objects.
+Create a new type by excluding properties corresponding to key `K` from object `T`, preserving the nested structure.
 
-```ts
+```typescript
 type Example = {
   user: {
     name: string;
@@ -46,42 +49,30 @@ type Example = {
 type Omitted = DeepStrictOmit<Example, 'user.name'>;
 ```
 
-This is also useful for branding types. Below is an example of defining a branding type using a library called typia, in which DeepStrictOmit can also be safely used.
+This is particularly effective for branded types. Below is an example using the `typia` library:
 
-```ts
-test('TEST 1. apply DeepStrictOmit to primitive property type of branding type', () => {
+```typescript
+test('Apply DeepStrictOmit to branding types', () => {
   type TestInterface = {
     id: string;
-    title: string;
     thumbnails: {
-      name: null | (string & MinLength<1> & MaxLength<255>);
-      extension: null | (string & MinLength<1> & MaxLength<8>);
+      name: string & MinLength<1> & MaxLength<255>;
       url: string;
     }[];
   };
 
   type Question = DeepStrictOmit<TestInterface, 'id'>;
-  type IsAnswer = Equal<
-    Question,
-    {
-      title: string;
-      thumbnails: {
-        name: null | (string & MinLength<1> & MaxLength<255>);
-        extension: null | (string & MinLength<1> & MaxLength<8>);
-        url: string;
-      }[];
-    }
-  >;
+  type IsAnswer = Equal<Question, { thumbnails: { name: string & MinLength<1> & MaxLength<255>; url: string }[] }>;
 
   ok(typia.random<IsAnswer>());
 });
 ```
 
-## DeepStrictPick
+### `DeepStrictPick`
 
-`DeepStrictPick<T, K>` creates a new type by selecting only the properties corresponding to the key K from object T, while preserving the nested structure. It allows safely selecting specific keys even from deep objects.
+Select properties corresponding to key `K` from object `T`, preserving the nested structure.
 
-```ts
+```typescript
 type Example = {
   user: {
     name: string;
@@ -93,38 +84,64 @@ type Example = {
 type Picked = DeepStrictPick<Example, 'user.name'>;
 ```
 
-## DeepStrictUnbrand
+### `DeepStrictUnbrand`
 
-DeepStrictUnbrand<T> removes branding from type T and applies it even to deeply nested objects. This makes handling complex branded types simpler by removing the branding for more straightforward use.
+Remove branding from type `T`, even in deeply nested objects, simplifying the handling of branded types.
 
-```ts
-type BrandedType = { brand: number & { type: 'won' } };
+```typescript
+type BrandedType = { value: number & { unit: 'dollar' } };
 
 // Result: { value: number; }
 type Unbranded = DeepStrictUnbrand<BrandedType>;
 ```
 
-## SubTypes for implementation
+### `GetType`
 
-### ElementOf
+Get the type of a specific key path from a nested object type `T`. This is useful for extracting the type of deeply nested properties safely.
 
-ElementOf<T> extracts the type of elements from an array type T. This is useful to explicitly define the element type of an array and perform operations on that element.
+```typescript
+type Example = {
+  user: {
+    name: string;
+    address: {
+      city: string;
+      zip: number;
+    };
+  };
+};
+
+// Result: string
+type CityType = GetType<Example, 'user.address.city'>;
+
+// Result: { city: string; zip: number; }
+type AddressType = GetType<Example, 'user.address'>;
+```
+
+## Utility SubTypes
 
-```ts
+### `ElementOf`
+
+Extract the type of elements from an array type `T`.
+
+```typescript
 type ArrayExample = string[];
 
 // Result: string
 type ElementType = ElementOf<ArrayExample>;
 ```
 
-### Equal
+### `Equal`
 
-Equal<A, B> evaluates whether types A and B are the same and returns true or false. This is used to validate whether two types are identical.
+Evaluate whether types `A` and `B` are the same, returning `true` or `false`. Useful for type validation.
 
-```ts
+```typescript
 type A = { a: number };
 type B = { a: number };
 
 // Result: true
 type AreEqual = Equal<A, B>;
 ```
+
+---
+
+This is just a part of the features provided by **DeepStrictTypes**, designed to enhance TypeScript's type manipulation capabilities and improve developer productivity. For more details, check out the library's full documentation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kakasoo/deep-strict-types",
-  "version": "1.0.25",
+  "version": "1.0.26",
   "description": "",
   "private": false,
   "publishConfig": {
@@ -47,13 +47,13 @@
   "author": "kakasoo",
   "license": "ISC",
   "devDependencies": {
-    "@samchon/shopping-api": "^0.12.1",
-    "@types/node": "^22.10.2",
+    "@samchon/shopping-api": "^0.14.1",
+    "@types/node": "^22.10.10",
     "prettier": "^3.4.2",
     "rimraf": "^6.0.1",
     "ts-patch": "^3.3.0",
-    "typescript": "^5.7.2",
-    "typia": "^7.5.1"
+    "typescript": "^5.7.3",
+    "typia": "^7.6.0"
   },
   "repository": {
     "type": "git",