TypeScript check for empty string

You can use this trick in your specific case:

function fn<T extends string>(a: T extends '' ? never : T) {
  // But TypeScript won't know here that !!a === true
}

fn(''); // Error
fn('foo'); // No error

I believe this is as close as you're going to get only using the typing system (rather than having a 'nonEmptyString' class)

type nonEmptyString = never; // Cannot be implicitly cast to
function isNonEmptyString(str: string): str is nonEmptyString {
    return str && str.length > 0; // Or any other logic, removing whitespace, etc.
}

Testing it:

let fn = function(a: nonEmptyString) {

}

let someStr = '';
if (isNonEmptyString(someStr)) {
    fn(someStr); // Valid
} else {
    fn(someStr); // Compile error
}

Unfortunately, you end up with warts since nonEmptyString is never. Which means you need to explicitly cast nonEmptyString back to string.

let fn = function(a: nonEmptyString) {
    let len = a.length; // Invalid
    let len2 = (<string>a).length; // Valid
    let str = a + 'something else'; // Valid (str is now typed as string)
}

One possible resolution is:

type nonEmptyString = string & { __nonEmptyStr: never };

Which alleviates the problem of having to explicitly cast back to a string (all three tests above are valid), but does pollute the type with __nonEmptyStr (which will be undefined if referenced).

You could maybe type it with overloads such as to give a bad return type on "" that will make things error as soon as you use it elsewhere:

type MyFnType = {
  (a: "") => never;
  (a: string) => whatever;
}

function fn: MyFnType = ...