larry babby and threejs for glsl

webGl/my-threejs-test/node_modules/@parcel/events/test/Disposable.test.js

@@ -0,0 +1,118 @@
+// @flow strict-local
+
+import assert from 'assert';
+import Disposable from '../src/Disposable';
+import {AlreadyDisposedError} from '../src/errors';
+
+describe('Disposable', () => {
+  it('can wrap an IDisposable', () => {
+    let disposed;
+
+    new Disposable({
+      dispose() {
+        disposed = true;
+      },
+    }).dispose();
+    assert.equal(disposed, true);
+  });
+
+  it('can wrap a function to dispose', () => {
+    let disposed;
+    new Disposable(() => {
+      disposed = true;
+    }).dispose();
+    assert.equal(disposed, true);
+  });
+
+  it('can wrap many disposable-likes', () => {
+    let disposed1;
+    let disposed2;
+
+    new Disposable(
+      {
+        dispose() {
+          disposed1 = true;
+        },
+      },
+      () => {
+        disposed2 = true;
+      },
+    ).dispose();
+    assert.equal(disposed1, true);
+    assert.equal(disposed2, true);
+  });
+
+  it('can add disposables after construction', () => {
+    let disposed1;
+    let disposed2;
+    let disposed3;
+    let disposed4;
+
+    let disposable = new Disposable(
+      {
+        dispose() {
+          disposed1 = true;
+        },
+      },
+      () => {
+        disposed2 = true;
+      },
+    );
+
+    disposable.add(
+      () => {
+        disposed3 = true;
+      },
+      {
+        dispose() {
+          disposed4 = true;
+        },
+      },
+    );
+
+    assert.notEqual(disposed1, true);
+    assert.notEqual(disposed2, true);
+    assert.notEqual(disposed3, true);
+    assert.notEqual(disposed4, true);
+
+    disposable.dispose();
+
+    assert.equal(disposed1, true);
+    assert.equal(disposed2, true);
+    assert.equal(disposed3, true);
+    assert.equal(disposed4, true);
+  });
+
+  it(
+    'does not dispose inner disposables more than once,' +
+      ' and does not throw on subsequent disposals',
+    () => {
+      let disposed;
+      let disposable = new Disposable(() => {
+        if (disposed) {
+          // $FlowFixMe
+          assert.fail();
+        }
+        disposed = true;
+      });
+
+      disposable.dispose();
+      disposable.dispose();
+    },
+  );
+
+  it('throws if `add` is called after it has been disposed', () => {
+    let disposable = new Disposable();
+    disposable.dispose();
+    assert.throws(() => {
+      disposable.add(() => {});
+    }, AlreadyDisposedError);
+  });
+
+  it('can be checked for disposal state', () => {
+    let disposable = new Disposable();
+    assert.equal(disposable.disposed, false);
+    disposable.dispose();
+    assert.equal(disposable.disposed, true);
+  });
+});

webGl/my-threejs-test/node_modules/@parcel/events/test/ValueEmitter.test.js

@@ -0,0 +1,100 @@
+// @flow strict-local
+
+import assert from 'assert';
+import ValueEmitter from '../src/ValueEmitter';
+import {AlreadyDisposedError} from '../src/errors';
+
+describe('ValueEmitter', () => {
+  let emitter: ValueEmitter<number>;
+  let values: Array<number>;
+
+  beforeEach(() => {
+    emitter = new ValueEmitter();
+    values = [];
+  });
+
+  afterEach(() => {
+    emitter.dispose();
+  });
+
+  function numberListener(x: number): void {
+    values.push(x);
+  }
+
+  it('registers new listeners and can dispose of them', () => {
+    let disposable = emitter.addListener(numberListener);
+    assert.deepEqual(emitter._listeners, [numberListener]);
+
+    disposable.dispose();
+    assert.deepEqual(emitter._listeners, []);
+  });
+
+  it('emits values to registered listeners', () => {
+    let disposable = emitter.addListener(numberListener);
+    emitter.emit(42);
+    assert.deepEqual(values, [42]);
+
+    disposable.dispose();
+  });
+
+  it('does not emit to listeners that were just registered', () => {
+    let innerDisposable;
+    let disposable = emitter.addListener(() => {
+      innerDisposable = emitter.addListener(numberListener);
+    });
+
+    emitter.emit(42);
+    assert.deepEqual(values, []);
+
+    emitter.emit(27);
+    assert.deepEqual(values, [27]);
+
+    disposable.dispose();
+    innerDisposable && innerDisposable.dispose();
+  });
+
+  it('finishes emitting even if a listener disposes of the emitter mid-emit', () => {
+    let disposableA = emitter.addListener(() => {
+      emitter.dispose();
+    });
+
+    let disposableB = emitter.addListener(numberListener);
+
+    emitter.emit(42);
+    assert.deepEqual(values, [42]);
+
+    disposableA.dispose();
+    disposableB.dispose();
+  });
+
+  it('clears listeners when disposed', () => {
+    let disposable = emitter.addListener(numberListener);
+    assert.deepEqual(emitter._listeners, [numberListener]);
+
+    emitter.dispose();
+    assert.deepEqual(emitter._listeners, []);
+
+    disposable.dispose();
+  });
+
+  it('throws when adding a listener when already disposed', () => {
+    emitter.dispose();
+    assert.throws(() => {
+      emitter.addListener(numberListener);
+    }, AlreadyDisposedError);
+  });
+
+  it('throws when emitting when already disposed', () => {
+    emitter.dispose();
+    assert.throws(() => {
+      emitter.emit(42);
+    }, AlreadyDisposedError);
+  });
+
+  it('can be disposed multiple times', () => {
+    emitter.dispose();
+    assert.doesNotThrow(() => {
+      emitter.dispose();
+    });
+  });
+});