DisposableStack : mthode move()

move()

let resource1;

function init() {
  using disposer = new DisposableStack();
  resource1 = disposer.use(getResource1());
  // ...
  // Abandonner la possession juste avant de retourner
  return disposer.move();
}

// Rcuprer la possession juste aprs le retour
using disposer = init();

let resource1;

function init() {
  using disposer = new DisposableStack();
  resource1 = disposer.use(getResource1());
  // ...
  const newDisposer = disposer.move();
  // Si quelqu'un ajoute du code entre ces lignes et qu'une erreur
  // survient, il n'y aurait aucun propritaire pour librer resource1
  return newDisposer;
}

using disposer = init();

function init() {
  using disposer = new DisposableStack();
  const resource1 = disposer.use(getResource1());
  // ...
  return { disposer: disposer.move(), resource1 };
}

const { resource1, ...rest } = init();
// Si quelqu'un ajoute du code entre ces lignes et qu'une erreur
// survient, il n'y aurait aucun propritaire pour librer resource1
using disposer = rest.disposer;

using disposer = new DisposableStack();
const server = disposer.use(makeServer());
await server.init();
if (server.ready) {
  // Serveur initialis avec succs ; il doit maintenant vivre pendant le
  // reste du programme. Abandonner son gestionnaire et ne pas le
  // rcuprer. Il ne sera plus jamais libr.
  disposer.move();
}
// Si on atteint la fin de la porte sans excuter disposer.move(), alors
// le serveur n'est pas prt pour une raison quelconque, et on libre ses
// ressources en librant le gestionnaire.

function consumeStack(stack) {
  using newStack = stack.move(); // newStack possde maintenant les gestionnaires
  console.log(stack.disposed); // true
  console.log(newStack.disposed); // false
  // newStack est libr ici juste avant la sortie de la fonction
}

const stack = new DisposableStack();
console.log(stack.disposed); // false
consumeStack(stack);
console.log(stack.disposed); // true

class PluginHost {
  #disposed = false;
  #disposables;
  #channel;
  #socket;

  constructor() {
    // Crer un DisposableStack qui est libr en sortie du constructeur.
    // Si la construction russit, on dplace tout hors de `disposer` et
    // dans `#disposables` pour une libration ultrieure.
    using disposer = new DisposableStack();

    // Crer un adaptateur IPC autour de process.send/process.on("message").
    // Lors de la libration, il se dsabonne de process.on("message").
    this.#channel = disposer.use(new NodeProcessIpcChannelAdapter(process));

    // Crer un pseudo-websocket qui envoie et reoit des messages par
    // un canal IPC NodeJS.
    this.#socket = disposer.use(new NodePluginHostIpcSocket(this.#channel));

    // Si on arrive ici, il n'y a eu aucune erreur pendant la
    // construction et on peut dplacer les objets librables hors de
    // `disposer` et dans `#disposables`.
    this.#disposables = disposer.move();

    // Si la construction choue, alors `disposer` sera libr avant
    // d'atteindre la ligne ci-dessus. Les gestionnaires d'vnements
    // seront supprims, permettant  `#channel` et `#socket` d'tre
    // collects par le collecteur de dchets (garbage collector).
  }

  [Symbol.dispose]() {
    if (this.#disposed) {
      return;
    }
    this.#disposed = true;
    // Placer `this.#disposables` dans une variable `using`, pour qu'elle
    // soit automatiquement libre  la sortie de la fonction.
    using disposables = this.#disposables;

    // REMARQUE : on peut librer `#socket` et `#channel` ici puisqu'ils
    // seront librs par l'appel  `disposables[Symbol.dispose]()`,
    // ci-dessous.
    // Ce n'est pas strictement obligatoire pour chaque objet librable,
    // mais c'est une bonne pratique puisque ces objets ne seront plus
    // utilisables.
    this.#socket = undefined;
    this.#channel = undefined;
    this.#disposables = undefined;
  }
}