Estou tentando descobrir se é possível lidar com vários níveis de parâmetros padrão com a desestruturação. Como não é fácil explicar com palavras, aqui está um exemplo passo a passo ...

1 - Destruição de objeto plano com parâmetros padrão

A reestruturação deste objeto é fácil:

let obj = {
  foo: 'Foo',
  bar: 'Bar'
};

Com{foo = 'Foo', bar = 'Bar'} = {} em uma assinatura de função, um objeto será criado se não houver nenhum argumento passado quando a função for chamada. Se um objeto for passado, mas algumas propriedades referenciadas foremundefined, eles serão substituídos por seus valores padrão. Este código funciona bem:

function fn1({foo = 'Foo', bar = 'Bar'} = {}) {
  console.log(foo, bar);
}

// OK
fn1(); // Foo Bar
fn1({foo: 'Quux'}); // Quux Bar
fn1({bar: 'Quux'}); // Foo Quux
fn1({foo: 'Quux', bar: 'Quux'}); // Quux Quux

2 - Destruição de objeto aninhado com parâmetros padrão rasos

A reestruturação desse objeto é mais difícil:

let obj = {
  foo: 'Foo',
  bar: {
    quux: 'Quux',
    corge: 'Corge'
  }
};

{foo = 'Foo', bar = 'Bar'} = {} não é mais uma opção viável, mas agora podemos usar{foo = 'Foo', bar = {quux: 'Quux', corge: 'Corge'}} = {} em uma assinatura de função. Novamente, se nenhum argumento for fornecido quando a função for chamada, um objeto será criado e as propriedades principais (foo ebar) são extraídos. Se um objeto for passado, apenas propriedades indefinidas (foo oubar) serão destruídos com seus valores padrão.

O problema é que as propriedades do objeto debar (quux ecorge) não fazem parte da "desestruturação de nível superior". Isso significaquux oucorge seráundefined se eles não estiverem explicitamente definidos quandobar é passado como argumento:

function fn2({foo = 'Foo', bar = {quux: 'Quux', corge: 'Corge'}} = {}) {
  console.log(foo, bar.quux, bar.corge);
}

// OK
fn2(); // Foo Quux Corge
fn2({foo: 'Quux'}); // Quux Quux Corge

// Oops!
fn2({bar: {quux: 'Baz'}}); // Foo Baz undefined
fn2({foo: 'Quux', bar: {corge: 'Baz'}}); // Quux undefined Baz

3 - Destruição de objeto aninhado com parâmetros padrão profundos

Eu gostaria de definir parâmetros padrão em todos os níveis da hierarquia de objetos para usar uma espécie de "desestruturação em cascata". Eu tentei isso, mas não funciona:

function fn3({foo = 'Foo', bar = ({quux = 'Quux', corge = 'Corge'} = {})} = {}) {
  console.log(foo, bar.quux, bar.corge);
}

// Oops!
fn3(); // Foo undefined undefined
fn3({foo: 'Quux'}); // Quux undefined undefined
fn3({bar: {quux: 'Baz'}}); // Foo Baz undefined
fn3({foo: 'Quux', bar: {corge: 'Baz'}}); // Quux undefined Baz

Você sabe se esse recurso é permitido no ES6. Se sim, como posso implementá-lo?