Антон Горецкий

function exportConstruct<P extends any[], T>(classFromExport: { new (...args: P): T; }): 
(...args: P) => T {
  return (...args) => new classFromExport(...args);
}

function exportCallable<T extends { new (...args: any[]): any; }>(classFromExport: T) {
  return new Proxy(classFromExport, {
    apply(ctor, _, args) {
      return new ctor(...args);
    }
  }) as T & ((...args: ConstructorParameters<T>) => InstanceType<T>);
}

const Lol = exportCallable(class Lol extends BaseLol {
  constructor(public name: string) {
    super();
    this.name = name.toUpperCase();
  }
});

Lol('qwe');

abstract class Newable {
  static new<P extends any[], T>(this: { new (...args: P): T; }, ...args: P): T { 
    return (new this(...args)) as T
  }
}

class BaseLol extends Newable {  /* ... */ }

class Lol extends BaseLol {
  constructor(public name: string) {
    super();
    this.name = name.toUpperCase();
  }
}

Lol.new('qwe');

const inputs = [...document.getElementsByClassName('inputs')];

function onInput() {
  if (this.value.length === this.maxLength) {
    inputs[-~inputs.indexOf(this)]?.focus();
  }

  if (inputs.every(n => n.value.length === n.maxLength)) {
    console.log('ВСЕ ЗАПОЛНЕНЫ');
  }
}

for (const n of inputs) {
  n.addEventListener('input', onInput);
}

const inputs = document.querySelectorAll('.inputs');

inputs.forEach(function(n) {
  n.addEventListener('input', this);
}, function({ target: t }) {
  const isFilled = t.value.length === t.maxLength;
  if (isFilled) {
    t.nextElementSibling?.focus();
  }

  if (this[isFilled ? 'add' : 'delete'](t).size === inputs.length) {
    console.log('ВСЕ ЗАПОЛНЕНЫ');
  }
}.bind(new Set));

const Property = ({ data, onDelete }) => (
  <div>
    #{data.id}
    <button onClick={onDelete}>Del</button>
  </div>
);

const ConstructorPage = () => {
  const [ properties, setProperties ] = useState([]);
  const delProperty = property => setProperties(properties.filter(n => n !== property));
  const addProperty = () => setProperties([
    ...properties,
    {
      id: 1 + Math.max(0, ...properties.map(n => n.id)),
    },
  ]);
  
  return (
    <> 
      <button onClick={addProperty}>Add</button>
      {properties.map(n => (
        <Property
          key={n.id}
          data={n}
          onDelete={() => delProperty(n)}
        />
      ))}
    </>
  );
};

new Promise(resolve => {
  // здесь код выполняется синхронно
  resolve();
}).then(() => {
  // здесь уже асинхронно, в ближайшем микротаске после вызова resolve выше
});

Promise.resolve().then(() => {
  // здесь тоже асинхронно, в ближайшем микротаске
});

много вычислений

handleChange = (name) => ({ target }) => {
    this.setState({ [name]: target.value });
};

handleChange = function(name) {
    return function({ target }) {
        this.setState({ [name]: target.value });
    };
};

handleChange = function(name) {
    return function(obj) {
        this.setState({ [name]: obj.target.value });
    };
};