because your constructor is always returning the same object, in your example, doing the same you do with the class, it would be:

const a = {name: 'name'}
const b = a;

console.log(a === b) // true

also const b = new App('car'); will not work. it will also get the class initiated with new App('test').

what you may want:

const appInstances = {};

class App {
  public static getSingleton(key) {
    if(!appInstances[key]) {
      appInstances[key] = new App(key);
    }
    return appInstances[key];
  }

  constructor(data) {
    this.data = data;
  }
}

const a = App.getSingleton('test');
const b = App.getSingleton('car');
console.log(a === b) // false

It's because if you return an object out of a constructor, the result of the new is the object you return, not the new object that was being created.

Your code does that by setting (initially) and then returning App.instance, so only the first instance of App you create will ever be returned by the constructor, all the others will be thrown away.

We can see that in action if we modify the example a bit:

class App {
    constructor(data, previous) {
        if (previous) {
            console.log(`this === previous? ${this === previous}`);
            console.log(`this === App.instance? ${this === App.instance}`);
            console.log(`previous === App.instance? ${previous === App.instance}`);
        }
        this.instance; // This doesn't do anything, btw
        this.data = data;
        if (App.instance) {
            console.log("Returning previous App.instance");
            return App.instance
        }
        console.log("Setting up and returning first App.instance");
        App.instance = this
        return App.instance
    }
}

const a = new App("test");
/* Logs:
Setting up and returning first App.instance
*/
const b = new App("car", a);
/* Logs:
this === previous? false
this === App.instance? false
previous === App.instance? true
Returning previous App.instance
*/
console.log(a === b);

.as-console-wrapper {
    max-height: 100% !important;
}

As you can see, during the second call to new App where we pass in a, a new instance was created (this === previous? false), but the earlier one was returned.

There is one singleton and which is calling twice. You have one class having static variable instance. It will be created only once in the application life cycle. Following code lines will be executed on first time.

 App.instance = this
 return App.instance

For second time or later, above code will not be accessible because of the following code

if (App.instance) {
  console.log("Returning previous App.instance");
  return App.instance
}

Here code is returning the same object which was created on first time. So actually same object returns on second and later calling. That is why reference of object remains same every time you call it.