StringKeyOf: Rename to KeyAsString (#1182)

Author: som-sm

index.d.ts

@@ -94,7 +94,7 @@ export type {LessThan} from './source/less-than.d.ts';
 export type {LessThanOrEqual} from './source/less-than-or-equal.d.ts';
 export type {Sum} from './source/sum.d.ts';
 export type {Subtract} from './source/subtract.d.ts';
-export type {StringKeyOf} from './source/string-key-of.d.ts';
+export type {KeyAsString} from './source/key-as-string.d.ts';
 export type {Exact} from './source/exact.d.ts';
 export type {ReadonlyTuple} from './source/readonly-tuple.d.ts';
 export type {OptionalKeysOf} from './source/optional-keys-of.d.ts';

readme.md

@@ -148,7 +148,7 @@ Click the type names for complete docs.
 - [`Simplify`](source/simplify.d.ts) - Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
 - [`SimplifyDeep`](source/simplify-deep.d.ts) - Deeply simplifies an object type.
 - [`Get`](source/get.d.ts) - Get a deeply-nested property from an object using a key path, like [Lodash's `.get()`](https://lodash.com/docs/latest#get) function.
-- [`StringKeyOf`](source/string-key-of.d.ts) - Get keys of the given type as strings.
+- [`KeyAsString`](source/key-as-string.d.ts) - Get keys of the given type as strings.
 - [`Schema`](source/schema.d.ts) - Create a deep version of another object type where property values are recursively replaced into a given value type.
 - [`Exact`](source/exact.d.ts) - Create a type that does not allow extra properties.
 - [`OptionalKeysOf`](source/optional-keys-of.d.ts) - Extract all optional keys from the given type.

source/get.d.ts

@@ -2,7 +2,7 @@ import type {ApplyDefaultOptions, ToString} from './internal/index.d.ts';
 import type {LiteralStringUnion} from './literal-union.d.ts';
 import type {Paths} from './paths.d.ts';
 import type {Split} from './split.d.ts';
-import type {StringKeyOf} from './string-key-of.d.ts';
+import type {KeyAsString} from './key-as-string.d.ts';
 import type {DigitCharacter} from './characters.d.ts';
 
 type GetOptions = {
@@ -112,7 +112,7 @@ type WithStringsKeys = keyof WithStrings;
 ```
 */
 type WithStringKeys<BaseType> = {
-	[Key in StringKeyOf<BaseType>]: UncheckedIndex<BaseType, Key>
+	[Key in KeyAsString<BaseType>]: UncheckedIndex<BaseType, Key>
 };
 
 /**

source/string-key-of.d.ts renamed to source/key-as-string.d.ts

@@ -9,17 +9,17 @@ Use-cases:
 
 @example
 ```
-import type {StringKeyOf} from 'type-fest';
+import type {KeyAsString} from 'type-fest';
 
 type Foo = {
-	1: number,
-	stringKey: string,
+	1: number;
+	stringKey: string;
 };
 
-type StringKeysOfFoo = StringKeyOf<Foo>;
+type StringKeysOfFoo = KeyAsString<Foo>;
 //=> '1' | 'stringKey'
 ```
 
 @category Object
 */
-export type StringKeyOf<BaseType> = `${Extract<keyof BaseType, string | number>}`;
+export type KeyAsString<BaseType> = `${Extract<keyof BaseType, string | number>}`;

test-d/key-as-string.ts

@@ -0,0 +1,27 @@
+import {expectType} from 'tsd';
+import type {KeyAsString} from '../source/key-as-string.d.ts';
+
+declare const foo: KeyAsString<{
+	1: number;
+	stringKey: string;
+}>;
+
+expectType<'1' | 'stringKey'>(foo);
+
+declare const sym: unique symbol;
+expectType<'1' | 'foo'>({} as KeyAsString<{[sym]: unknown; 1: number; foo: string}>); // Ignores symbol keys
+
+// Index signatures
+expectType<string>({} as KeyAsString<{[x: string]: unknown}>);
+expectType<`${number}`>({} as KeyAsString<{[x: number]: unknown}>);
+expectType<`foo${string}` | `${number}`>({} as KeyAsString<{[x: `foo${string}`]: unknown; [y: number]: unknown}>);
+expectType<string>({} as KeyAsString<{[x: string]: unknown; [y: symbol]: unknown}>);
+expectType<never>({} as KeyAsString<{[x: symbol]: unknown}>);
+
+// Unions
+expectType<'1'>({} as KeyAsString<{1: number; foo: string} | {1: number; bar: string}>); // Only grabs the common keys, just like `keyof`.
+expectType<never>({} as KeyAsString<{foo: string} | {bar: string}>);
+
+// Boundary cases
+expectType<string>({} as KeyAsString<any>);
+expectType<string>({} as KeyAsString<never>);