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,49 @@
+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,95 @@
+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 // evaluates to 'foo' | 0
+type WithStringsKeys = keyof WithStrings // evaluates to '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;
+
+/**
+Gets a deeply-nested property from an object, like lodash's `get` method.
+
+Use-case: retrieve a property from deep inside an API response or 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 }>
+```
+
+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.
+ */
+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];