About

This PR intends to fix the issue reported on #136 , where I described the workaround for avoiding type check error in TypeScript.

The goal of this PR is making msgpack-javascript available from TypeScript both with/without enabling strictNullCheck compile option.

Since I don't know the actual intention of the original implementer ( @grantila ), the change in this PR might be controversial.

So, though it would be appreciated if you welcome this PR, I highly recommend to ask @grantila 's opinion.

Background

Issue of the current implementation

I think this implementation has some issues.

issue of SplitTypes when strictNullCheck is disabled:

This short code describes the issue.

As I wrote in the inline comment, given type Split<T, U> = U extends T ? U : Exclude<T, U>, Split<T, undefined> is always evaluated as never unless T is undefined because undefined is subtype of all other types when strictNullCheck is disabled. (see TypeScript: Handbook - Basic Types)

This behavior is the cause of the issue that i reported in #136.

Lets say, if you write the following code in this circumstance:

const extensionCodec = new ExtensionCodec<MyContext>();
// snip...
const context = new MyContext();
const encoded = encode({new MyType(), { extensionCodec, context });

This code wouldn't be able to compiled as I reported.

The reason can be seen by gradually evaluating encode({myType: new MyType<any>()}, { extensionCodec, context });:

encode({myType: new MyType<any>()}, { extensionCodec, context });
// => encode<MyContext>(unknown, { ExtensionCodecType<MyContext>, context });
// => encode<MyContext>(unknown, EncodeOptions<SplitUndefined<MyContext>>)
// => encode(unknown, EncodeOptions<never>)
// { extensionCodec, context } doesn't match EncodeOptions<never>

This code emulates the issue of the actual code.

above issue can be resolved when strictNullCheck is enabled, but ...

So, by enabling strictNullCheck, this issue can be solved as I reported in #136.

But, this is not ideal because client code is forced to enable strictNullCheck.

I was wondering if it's possible to achieve the goal (using msgpack-javascript by TypeScript without enabling strictNullCheck and without changing its API).

Then, I found one weird behavior of SplitTypes when the strictNullCheck is enabled.

// When strictNullCheck is enabled
type Split<T, U> = U extends T ? U : Exclude<T, U>;
type SplitUndefined<T> = Split<T, undefined>
let a: SplitUndefined<undefined> = undefined;
let b: SplitUndefined<number> = 1;
// SplitUndefined<number | undefined> is undefined
let c: SplitUndefined<number | undefined> = undefined
let d: SplitUndefined<number | undefined> = 1 // error

(actual code is here)

For me, given the name SplitUndefined, I felt weird if SplitUndefined<number | undefined> is evaluated as undefined. Rather, it seems natural for SplitUndefined<number | undefined> to be evaluated as number, for me.

Besides, Split<T, U> = U extends T ? U : Exclude<T, U> seems logically incorrect.
Given U is not subtype of T, T won't be the Union Type that contains U. Thus, Exclude<T, U> never excludes U.

So, I started to think this is the bug that @grantila ( original implementer of this code ) didn't intend.

It's really long and winding explanation, that was the story I addressed this PR.

About the changes

Essential change in this PR is the following change.

https://github.com/msgpack/msgpack-javascript/pull/139/files#diff-a7af09f7fa8732629ff9579258b5584bR3

The behavior of this Code is like following code:

export type SplitTypes<T, U> = U extends T
 ? Exclude<T, U> extends never ? T : Exclude<T, U>
 : T;
export type SplitUndefined<T> = SplitTypes<T, undefined>;
let a: SplitUndefined<undefined> = undefined;
let b: SplitUndefined<number> = 1;
// SplitUndefined<number | undefined> is undefined
let c: SplitUndefined<number | undefined> = undefined // error
let d: SplitUndefined<number | undefined> = 1

This code behave same regardless of the state of strictNullCheck

• When strictNullCheck is enabled
• When strictNullCheck is disabled

The rest of changes are necessary changes so that type system works properly.