Clipper and Outliner throw once their world has been disposed, which aborts components.dispose() #839

// GPU-free check of Clipper / Outliner teardown after a world is deleted.
// Uses the published @thatopen/components(-front) 3.6.0 bundles; only the
// renderer, camera and canvas are stubbed, since they need WebGL / a DOM.
import * as THREE from "three";
import * as OBC from "@thatopen/components";
import * as OBCF from "@thatopen/components-front";

function fakeElement(): any {
  const el: any = {
    style: {},
    addEventListener() {},
    removeEventListener() {},
    getBoundingClientRect: () => ({ left: 0, top: 0, width: 100, height: 100 }),
    setPointerCapture() {},
    releasePointerCapture() {},
    parentElement: null,
  };
  el.ownerDocument = { pointerLockElement: null };
  return el;
}

function stubRenderer(): any {
  const r: any = {
    worlds: new Map(),
    onWorldChanged: new OBC.Event(),
    currentWorld: null,
    setPlane: () => {},
    updateClippingPlanes: () => {},
    dispose: () => {},
    three: { domElement: fakeElement() },
    postproduction: {
      excludedObjectsPass: { addExcludedMaterial() {} },
      outlinePass: {
        addGroup() {},
        configureGroup() {},
        removeGroup() {},
        detachOutlinedTile() {},
      },
      outlinesEnabled: false,
    },
  };
  return r;
}

function stubCamera(): any {
  return {
    three: new THREE.PerspectiveCamera(),
    onWorldChanged: new OBC.Event(),
    isDisposeable: () => true,
    isUpdateable: () => false,
    dispose: () => {},
    controls: { addEventListener() {}, removeEventListener() {} },
  };
}

function setup() {
  const components = new OBC.Components();
  const worlds = components.get(OBC.Worlds);
  const world = worlds.create<OBC.SimpleScene, any, any>();
  world.scene = new OBC.SimpleScene(components);
  world.camera = stubCamera();
  world.renderer = stubRenderer();
  return { components, worlds, world };
}

async function run(name: string, fn: () => void | Promise<void>) {
  try {
    await fn();
    console.log(`${name}: ok`);
  } catch (e) {
    console.log(`${name}: THROWS ${(e as Error).constructor.name}: ${(e as Error).message}`);
  }
}

console.log("@thatopen/components", (await import("@thatopen/components/package.json")).version);
console.log("@thatopen/components-front", (await import("@thatopen/components-front/package.json")).version);

// Clipper
{
  const { components } = setup();
  const world = [...components.get(OBC.Worlds).list.values()][0];
  const clipper = components.get(OBC.Clipper);
  clipper.createFromNormalAndCoplanarPoint(world, new THREE.Vector3(0, -1, 0), new THREE.Vector3());
  await run("A1 Clipper, components.dispose() only", () => components.dispose());
}
{
  const { components, worlds, world } = setup();
  const clipper = components.get(OBC.Clipper);
  clipper.createFromNormalAndCoplanarPoint(world, new THREE.Vector3(0, -1, 0), new THREE.Vector3());
  worlds.delete(world);
  console.log("   planes left in clipper.list after worlds.delete:", clipper.list.size);
  await run("A2 Clipper, worlds.delete(world) then clipper.deleteAll()", () => clipper.deleteAll());
}
{
  const { components, worlds, world } = setup();
  const clipper = components.get(OBC.Clipper);
  clipper.createFromNormalAndCoplanarPoint(world, new THREE.Vector3(0, -1, 0), new THREE.Vector3());
  let componentsDisposed = false;
  components.onDisposed.add(() => (componentsDisposed = true));
  worlds.delete(world);
  await run("A3 Clipper, worlds.delete(world) then components.dispose()", () => components.dispose());
  console.log("   components.onDisposed fired:", componentsDisposed);
}

// Outliner
{
  const { components, world } = setup();
  const outliner = components.get(OBCF.Outliner);
  outliner.world = world;
  await run("B1 Outliner, components.dispose() only", () => components.dispose());
}
{
  const { components, worlds, world } = setup();
  const outliner = components.get(OBCF.Outliner);
  outliner.world = world;
  worlds.delete(world);
  await run("B2 Outliner, worlds.delete(world) then outliner.clean()", () => outliner.clean());
  await run("B3 Outliner, worlds.delete(world) then components.dispose()", () => components.dispose());
}