Add Get type

package.json

@@ -36,6 +36,7 @@
 	],
 	"devDependencies": {
 		"@sindresorhus/tsconfig": "~0.7.0",
+		"expect-type": "^0.9.0",
 		"tsd": "^0.13.1",
 		"typescript": "^4.1.2",
 		"xo": "^0.35.0"

readme.md

@@ -97,6 +97,7 @@ Click the type names for complete docs.
 - [`PascalCase`](ts41/pascal-case.d.ts) – Converts a string literal to pascal-case (`FooBar`)
 - [`SnakeCase`](ts41/snake-case.d.ts) – Convert a string literal to snake-case (`foo_bar`).
 - [`DelimiterCase`](ts41/delimiter-case.d.ts) – Convert a string literal to a custom string delimiter casing.
+- [`Get`](ts41/get.d.ts) - Get a deeply-nested property from an object using a key path, like Lodash's `.get()` function.
 
 ### Miscellaneous
 

source/utilities.d.ts

@@ -1,3 +1,5 @@
 export type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'X' | 'Y' | 'Z';
 
 export type WordSeparators = '-' | '_' | ' ';
+
+export type Integers = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';

test-d/camel-case.ts

@@ -1,4 +1,5 @@
-import {Split, CamelCase} from '../source/camel-case';
+import {CamelCase} from '../source/camel-case';
+import {Split} from '../ts41/utilities';
 import {expectType, expectAssignable} from 'tsd';
 
 // Split

test-d/get.ts

@@ -0,0 +1,53 @@
+import {Get} from '../ts41/get';
+import {expectTypeOf} from 'expect-type';
+
+interface ApiResponse {
+  hits: {
+    hits: Array<{
+      _id: string;
+      _source: {
+        name: Array<{
+          given: string[];
+          family: string;
+        }>;
+        birthDate: string;
+      };
+    }>;
+  };
+}
+
+expectTypeOf<Get<ApiResponse, 'hits.hits[0]._source.name'>>().toEqualTypeOf<Array<{given: string[]; family: string}>>();
+expectTypeOf<Get<ApiResponse, 'hits.hits.0._source.name'>>().toEqualTypeOf<Array<{given: string[]; family: string}>>();
+
+expectTypeOf<Get<ApiResponse, 'hits.someNonsense.notTheRightPath'>>().toBeUndefined();
+
+interface WithTuples {
+  foo: [
+    {
+			bar: number
+		},
+    {
+			baz: boolean
+		}
+  ];
+}
+
+expectTypeOf<Get<WithTuples, 'foo[0].bar'>>().toBeNumber();
+expectTypeOf<Get<WithTuples, 'foo.0.bar'>>().toBeNumber();
+
+expectTypeOf<Get<WithTuples, 'foo[1].bar'>>().toBeUndefined();
+expectTypeOf<Get<WithTuples, 'foo.1.bar'>>().toBeUndefined();
+
+interface WithNumberKeys {
+  foo: {
+    1: {
+      bar: number;
+    };
+  };
+}
+
+expectTypeOf<Get<WithNumberKeys, 'foo[1].bar'>>().toBeNumber();
+expectTypeOf<Get<WithNumberKeys, 'foo.1.bar'>>().toBeNumber();
+
+expectTypeOf<Get<WithNumberKeys, 'foo[2].bar'>>().toBeUndefined();
+expectTypeOf<Get<WithNumberKeys, 'foo.2.bar'>>().toBeUndefined();

ts41/camel-case.d.ts

@@ -1,13 +1,5 @@
 import {WordSeparators} from '../source/utilities';
-
-/**
-Recursively split a string literal into two parts on the first occurence of the given string, returning an array literal of all the separate parts.
-*/
-export type Split<S extends string, D extends string> =
-	string extends S ? string[] :
-	S extends '' ? [] :
-	S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] :
-	[S];
+import {Split} from './utilities';
 
 /**
 Step by step takes the first item in an array literal, formats it and adds it to a string literal, and then recursively appends the remainder.

ts41/get.d.ts

@@ -0,0 +1,93 @@
+import {Split} from './utilities';
+import {Integers} from '../source/utilities';
+
+/**
+Like @see Get but receives an array of strings as a path parameter.
+*/
+type GetWithPath<T, Keys extends readonly string[]> =
+  Keys extends []
+  ? T
+  : Keys extends [infer Head, ...infer Tail]
+  ? GetWithPath<PropertyOf<T, Extract<Head, string>>, Extract<Tail, string[]>>
+  : never;
+
+type ToPath<S extends string> = Split<FixPathSquareBrackets<S>, '.'>;
+
+type FixPathSquareBrackets<S extends string> =
+  S extends `${infer T}[${infer U}]${infer V}`
+  ? `${T}.${U}${FixPathSquareBrackets<V>}`
+  : S;
+
+type ConsistsOnlyOf<S extends string, C extends string> =
+  S extends ''
+  ? true
+  : S extends `${C}${infer Tail}`
+  ? ConsistsOnlyOf<Tail, C>
+  : false;
+
+type IsInteger<S extends string> = ConsistsOnlyOf<S, Integers>;
+
+/**
+Convert a type which may have number keys to one with string keys, making it possible to index using strings retrieved from template types.
+
+@example
+```
+type WithNumbers = {foo: string; 0: boolean}
+type WithStrings = WithStringKeys<WithNumbers>
+
+type WithNumbersKeys = keyof WithNumbers
+//=> 'foo' | 0
+type WithStringsKeys = keyof WithStrings
+//=> 'foo' | '0'
+```
+*/
+type WithStringKeys<T extends Record<string | number, any>> = {
+  [K in `${Extract<keyof T, string | number>}`]: T[K]
+};
+
+/**
+Get a property of an object or array. Works when indexing arrays using number-literal-strings, e.g. `PropertyOf<number[], '0'>  = number`, and when indexing objects with number keys.
+
+Returns `neundefinedver` if `Key` is not a property of `Object`,
+*/
+type PropertyOf<ObjectType, Key extends string> =
+  Key extends keyof ObjectType
+  ? ObjectType[Key]
+  : ObjectType extends Array<infer Item>
+  ? IsInteger<Key> extends true
+  ? Item
+  : undefined
+  : Key extends keyof WithStringKeys<ObjectType>
+  ? WithStringKeys<ObjectType>[Key]
+  : undefined;
+
+// This works by first splitting the path based on `.` and `[...]` characters into a tuple of string keys. Then it recursively uses the head key to get the next property of the current object, until there are no keys left. Number keys extract the item type from arrays, or are converted to strings to extract types from tuples and dictionaries with number keys.
+/**
+Get a deeply-nested property from an object using a key path, like Lodash's `.get()` function.
+
+Use-case: Retrieve a property from deep inside an API response or some other complex object.
+
+@example
+```
+import {Get} from 'type-fest';
+
+interface ApiResponse {
+  hits: {
+    hits: Array<{
+      _id: string
+      _source: {
+        name: Array<{
+          given: string[]
+          family: string
+        }>
+        birthDate: string
+      }
+    }>
+  }
+}
+
+type Name = Get<ApiResponse, 'hits.hits[0]._source.name'>;
+//=> Array<{given: string[]; family: string}>
+```
+*/
+export type Get<Object, Path extends string> = GetWithPath<Object, ToPath<Path>>;

ts41/utilities.d.ts

@@ -0,0 +1,8 @@
+/**
+Recursively split a string literal into two parts on the first occurence of the given string, returning an array literal of all the separate parts.
+*/
+export type Split<S extends string, D extends string> =
+	string extends S ? string[] :
+	S extends '' ? [] :
+	S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] :
+	[S];