In TypeScript 2, you can use the undefined type to check for undefined values.

If you declare a variable as:

let uemail : string | undefined;

Then you can check if the variable uemail is undefined like this:

if(uemail === undefined)
{

}

Using a juggling-check, you can test both null and undefined in one hit:

if (x == null) {

If you use a strict-check, it will only be true for values set to null and won't evaluate as true for undefined variables:

if (x === null) {

You can try this with various values using this example:

var a: number;
var b: number = null;

function check(x, name) {
    if (x == null) {
        console.log(name + ' == null');
    }

    if (x === null) {
        console.log(name + ' === null');
    }

    if (typeof x === 'undefined') {
        console.log(name + ' is undefined');
    }
}

check(a, 'a');
check(b, 'b');

Output

"a == null"

"a is undefined"

"b == null"

"b === null"

Let me try to explain you what is typescript thinks about your code and how it acts:

class TestClass {
   // this is the worst possible getter for a typescript compiler
   // the random nature of the getter deceives both the compiler and the developer
    get person(): Person | undefined {
        if (Math.random() > 0.5) return undefined
        return { name: 'Bob', age: 35 }
    }

    get test() {
        if (!this.person) return undefined
        // In here TS compiler thinks that accessing this.person.name 
        // is safe because the above line has a guard for it.
        // But it will throw runtime errors by %50 chance
        // Note that TS doesn't aware of its randomness here
        const name = this.person.name //
        // If we describe this line we call it a local arrow function definition
        // Since it's a definition and also there is no nullability guard in it TS is right about complaining here
        // Since it's a definition it is not deterministic where it 
        // will be called in the code, and the compiler can't be sure whether it is null or not.
        const processPerson = () => this.person.name // Object is possibly 'undefined'.(2532)
        return processPerson()
    }
}

The other answers have already good practices to avoid the error and possible runtime issues.

You can make throwIfUndefined an assertion function to narrow the type of its argument to something that does not include undefined in its domain. An assertion function has an assertion type predicate of the form asserts x is Y as its return type, where x is the name of one of the function's parameters, and Y is the subtype of typeof X that we narrow x to assuming the function returns successfully. Assertion functions cannot return a defined value; they are basically void-returning functions.

For throwIfUndefined, here's the normal way to do it, as a function statement:

function throwIfUndefined<T>(x: T | undefined): asserts x is T {
    if (typeof x === "undefined") throw new Error("OH NOEZ");
}

You can also write it as an arrow function, although you need to explicitly annotate the variable with its type for the control flow analysis to happen correctly:

const throwIfUndefined: <T, >(x: T | undefined) => asserts x is T = x => {
    if (typeof x === "undefined") throw new Error("OH NOEZ");
}

Either way should work:

const Index = ({ params }: { params: { myVar: string | undefined } }) => {
    const { myVar } = params // myVar: string | undefined
    // myVar.toUpperCase // <-- error, Object is possibly 'undefined'
    throwIfUndefined(myVar);
    return myVar.toUpperCase() // no error now
}

try {
    console.log(Index({
        params: {
            myVar: Math.random() < 0.5 ? "hello" : undefined
        }
    })) // 50% "HELLO" 
} catch (e) {
    console.log(e); // 50% "OH NOEZ"
}

Playground link to code

if(!point && !optionB)

This IF block would be skipped if either point or optionB is undefined.

Let's say optionB is undefined..------------------(1) The first block is skipped, as per your condition.

obviously, TS will point out to you that optionB is possibly undefined in the second block (assumption (1))

Now Lets say point is undefined....................(2) The first block is skipped, as per your condition.

TS will again point to you that point is possibly undefined in the second block (assumption (2)).

This is why you see both linting errors.

Try to use conditional type with extra generic parameter

type a = boolean | undefined;

type IsUndefined<T> = undefined extends T ? true : false

type Result = IsUndefined<a> // true

type Result2 = IsUndefined<number | string> // false

Playground

When conditional types act on a generic type, they become distributive when given a union type (distributive-conditional-types). For example, take the following.

If we plug a union type into IsUndefined, then the conditional type will be applied to each member of that union.

type IsUndefined<T> = T extends undefined ? true : false

type Result = IsUndefined<string> | IsUndefined<undefined> // boolean

IsUndefined<string> returns false IsUndefined<undefined> returns true

Hence, Result is boolean because a union of true and false is a boolean.

But, if you put undefined before extends then conditional type will be applied to the whole union

The logical nullish assignment (x ??= y) operator only assigns if x is nullish (null or undefined).

x ??= default_value