[context] `createContext` function recommendation

[augustjk]

The current recommendation for createContext has

community-protocols/proposals/context.md

Lines 114 to 121 in 952f158

	### `createContext` functions
	It is recommended that TypeScript implementations provide a `createContext()` function which is used to create a `Context`. This function can just cast to a `Context`:
	```ts
	export const createContext = <ValueType>(key: unknown) =>
	key as Context<typeof key, ValueType>;
	```

This effectively makes typeof key to always be unknown.

Lit's implementation has

export function createContext<ValueType, K = unknown>(key: K) {
  return key as Context<K, ValueType>;
}

which allows taking an type argument for the context key. In order to take advantage of this though, both type arguments must be provided. If only ValueType is provided, K defaults to unknown as TypeScript does not do partial inference of type arguments.

Now in practice, I don't think having an explicit KeyType be provided to Context is quite necessary. The extraction of the ValueType does not require it:

community-protocols/proposals/context.md

Lines 101 to 104 in 952f158

	```ts
	export type ContextType<Key extends Context<unknown, unknown>> =
	Key extends Context<unknown, infer ValueType> ? ValueType : never;
	```

I'm a bit torn as it feels correct to allow explicitly typing the KeyType as in the Lit implementation, but if it's functionally moot, that creates confusion like lit/lit#4601

One issue with having KeyType be unknown is that it can look confusing. With unknown & {__context: ValueType}, it just looks like {__context: ValueType} in type intellisense.
e.g.

const key = Symbol('foo');
const foo = createContext<{foo: string}>(key);
//    ^? const foo: {
//           __context__: {
//               foo: string;
//           };
//       }

[Westbrook]

@augustjk did #59 fix this, or is there still more work that you'd like to see based on this?

[augustjk]

@augustjk did #59 fix this, or is there still more work that you'd like to see based on this?

No, that PR only fixed inconsistencies and keeps the same createContext example mentioned in the original post of this issue.

Though I don't have a clear idea on what the change I'd like to see here. It's not detrimental as is since everything is functional, but it just feels less polished with hardcoded unknown types for the context key. But then Lit's implementation which does preserve the type of context key has its own downside of having to explicitly pass in 2 types to createContext. The author of lit/lit#4601 proposes a type registry so that's another possibility but would require agreeing on the module/namespace for the type.

[justinfagnani]

Another option here is to drop the key type parameter. If keys are mostly used opaquely, then the value type is much more important. It's the type that producers and consumers need to use.

Yet another option is to wait for microsoft/TypeScript#26242 😄