@atlaspack/events 2.14.2-typescript-6de04fbae.0 → 2.14.2-typescript-08dcc1c9b.0

package/lib/Disposable.js

@@ -1,48 +1,46 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
-Object.defineProperty(exports, /*
+exports.default = void 0;
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+var _errors = require("./errors");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/*
  * A general-purpose disposable class. It can normalize disposable-like values
  * (such as single functions or IDisposables), as well as hold multiple
  * disposable-like values to be disposed of at once.
- */ "default", {
-    enumerable: true,
-    get: function() {
-        return Disposable;
-    }
-});
-const _assert = /*#__PURE__*/ _interop_require_default(require("assert"));
-const _errors = require("./errors.mjs");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
+ */
 class Disposable {
-    disposed = false;
-    #disposables;
-    constructor(...disposables){
-        this.#disposables = new Set(disposables);
+  disposed = false;
+  #disposables;
+  constructor(...disposables) {
+    this.#disposables = new Set(disposables);
+  }
+  add(...disposables) {
+    if (this.disposed) {
+      throw new _errors.AlreadyDisposedError('Cannot add new disposables after disposable has been disposed');
     }
-    add(...disposables) {
-        if (this.disposed) {
-            throw new _errors.AlreadyDisposedError('Cannot add new disposables after disposable has been disposed');
-        }
-        (0, _assert.default)(this.#disposables != null);
-        for (let disposable of disposables){
-            this.#disposables.add(disposable);
-        }
+    (0, _assert().default)(this.#disposables != null);
+    for (let disposable of disposables) {
+      this.#disposables.add(disposable);
     }
-    async dispose() {
-        if (this.disposed) {
-            return;
-        }
-        this.disposed = true;
-        (0, _assert.default)(this.#disposables != null);
-        await Promise.all([
-            ...this.#disposables
-        ].map((disposable)=>typeof disposable === 'function' ? disposable() : disposable.dispose()));
-        this.#disposables = null;
+  }
+  async dispose() {
+    if (this.disposed) {
+      return;
     }
+    this.disposed = true;
+    (0, _assert().default)(this.#disposables != null);
+    await Promise.all([...this.#disposables].map(disposable => typeof disposable === 'function' ? disposable() : disposable.dispose()));
+    this.#disposables = null;
+  }
 }
+exports.default = Disposable;

package/lib/ValueEmitter.js

@@ -1,72 +1,74 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
-Object.defineProperty(exports, // Like an EventEmitter, but for only a single "event". This provides type-safety
+exports.default = void 0;
+var _errors = require("./errors");
+// Like an EventEmitter, but for only a single "event". This provides type-safety
 // for the values emitted. Rather than passing predetermined strings (which can
 // be misspelled), create an instance of ValueEmitter for every logical "event"
 // to be dispatched, and type it according to the type of value emitted.
-"default", {
-    enumerable: true,
-    get: function() {
-        return ValueEmitter;
-    }
-});
-const _errors = require("./errors.mjs");
 class ValueEmitter {
-    // An array of listeners. One might think a Set would be better for O(1) removal,
-    // but splicing a JS array gets pretty close, and copying the array (as is done
-    // in emit) is far faster than a Set copy: https://github.com/atom/event-kit/pull/39
-    _listeners = [];
-    _disposed = false;
-    addListener(listener) {
-        if (this._disposed) {
-            throw new _errors.AlreadyDisposedError('Cannot add a listener since this ValueEmitter has been disposed');
-        }
-        this._listeners.push(listener);
-        // Close over a reference to this emitter in the disposable below, rather
-        // than referencing `this` directly. This allows us to set it to null after
-        // slicing out the listener.
-        // This prevents anyone holding onto the disposable after disposal from
-        // unintentionally retaining a reference to this emitter.
-        let emitter = this;
-        return {
-            dispose () {
-                if (emitter == null) {
-                    return;
-                }
-                if (emitter._disposed) {
-                    emitter = null;
-                    return;
-                }
-                let listeners = emitter._listeners;
-                let listenerIndex = listeners.indexOf(listener);
-                if (listenerIndex > -1) {
-                    listeners.splice(listenerIndex, 1);
-                }
-                emitter = null;
-            }
-        };
+  // An array of listeners. One might think a Set would be better for O(1) removal,
+  // but splicing a JS array gets pretty close, and copying the array (as is done
+  // in emit) is far faster than a Set copy: https://github.com/atom/event-kit/pull/39
+  _listeners = [];
+  _disposed = false;
+  addListener(listener) {
+    if (this._disposed) {
+      throw new _errors.AlreadyDisposedError('Cannot add a listener since this ValueEmitter has been disposed');
     }
-    emit(value) {
-        if (this._disposed) {
-            throw new _errors.AlreadyDisposedError('Cannot emit since this ValueEmitter has been disposed');
+    this._listeners.push(listener);
+
+    // Close over a reference to this emitter in the disposable below, rather
+    // than referencing `this` directly. This allows us to set it to null after
+    // slicing out the listener.
+    // This prevents anyone holding onto the disposable after disposal from
+    // unintentionally retaining a reference to this emitter.
+    let emitter = this;
+    return {
+      dispose() {
+        if (emitter == null) {
+          return;
         }
-        // Iterate over a copy of listeners. This prevents the following cases:
-        // * When a listener callback can itself register a new listener and be
-        //   emitted as part of this iteration.
-        // * When a listener callback disposes of this emitter mid-emit, preventing
-        //   other listeners from receiving the event.
-        let listeners = this._listeners.slice();
-        for(let i = 0; i < listeners.length; i++){
-            listeners[i](value);
+        if (emitter._disposed) {
+          // @ts-expect-error - Setting emitter to null to prevent memory leaks
+          emitter = null;
+          return;
         }
-    }
-    dispose() {
-        if (this._disposed) {
-            return;
+        let listeners = emitter._listeners;
+        let listenerIndex = listeners.indexOf(listener);
+        if (listenerIndex > -1) {
+          listeners.splice(listenerIndex, 1);
         }
-        this._listeners = [];
-        this._disposed = true;
+
+        // @ts-expect-error - Setting emitter to null to prevent memory leaks
+        emitter = null;
+      }
+    };
+  }
+  emit(value) {
+    if (this._disposed) {
+      throw new _errors.AlreadyDisposedError('Cannot emit since this ValueEmitter has been disposed');
+    }
+
+    // Iterate over a copy of listeners. This prevents the following cases:
+    // * When a listener callback can itself register a new listener and be
+    //   emitted as part of this iteration.
+    // * When a listener callback disposes of this emitter mid-emit, preventing
+    //   other listeners from receiving the event.
+    let listeners = this._listeners.slice();
+    for (let i = 0; i < listeners.length; i++) {
+      listeners[i](value);
+    }
+  }
+  dispose() {
+    if (this._disposed) {
+      return;
     }
+    this._listeners = [];
+    this._disposed = true;
+  }
 }
+exports.default = ValueEmitter;

package/lib/errors.js

@@ -1,15 +1,11 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
-Object.defineProperty(exports, "AlreadyDisposedError", {
-    enumerable: true,
-    get: function() {
-        return AlreadyDisposedError;
-    }
-});
-class AlreadyDisposedError extends Error {
-}
+exports.AlreadyDisposedError = void 0;
+class AlreadyDisposedError extends Error {}
+exports.AlreadyDisposedError = AlreadyDisposedError;
 Object.defineProperty(AlreadyDisposedError.prototype, 'name', {
-    value: 'AlreadyDisposedError'
-});
+  value: 'AlreadyDisposedError'
+});

package/lib/index.js

@@ -1,29 +1,27 @@
 "use strict";
+
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    AlreadyDisposedError: function() {
-        return _errors.AlreadyDisposedError;
-    },
-    Disposable: function() {
-        return _Disposable.default;
-    },
-    ValueEmitter: function() {
-        return _ValueEmitter.default;
-    }
+Object.defineProperty(exports, "AlreadyDisposedError", {
+  enumerable: true,
+  get: function () {
+    return _errors.AlreadyDisposedError;
+  }
 });
-const _Disposable = /*#__PURE__*/ _interop_require_default(require("./Disposable.mjs"));
-const _ValueEmitter = /*#__PURE__*/ _interop_require_default(require("./ValueEmitter.mjs"));
-const _errors = require("./errors.mjs");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
+Object.defineProperty(exports, "Disposable", {
+  enumerable: true,
+  get: function () {
+    return _Disposable.default;
+  }
+});
+Object.defineProperty(exports, "ValueEmitter", {
+  enumerable: true,
+  get: function () {
+    return _ValueEmitter.default;
+  }
+});
+var _Disposable = _interopRequireDefault(require("./Disposable"));
+var _ValueEmitter = _interopRequireDefault(require("./ValueEmitter"));
+var _errors = require("./errors");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/lib/types.js

@@ -1,4 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
+"use strict";

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@atlaspack/events",
-  "version": "2.14.2-typescript-6de04fbae.0",
+  "version": "2.14.2-typescript-08dcc1c9b.0",
   "license": "(MIT OR Apache-2.0)",
-  "type": "commonjs",
   "publishConfig": {
     "access": "public"
   },
@@ -11,25 +10,14 @@
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
   "main": "lib/index.js",
-  "types": "lib/index.d.mts",
+  "source": "src/index.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
-  "exports": {
-    ".": {
-      "atlaspack::sources": "./src/index.mts",
-      "types": [
-        "./lib/index.d.mts",
-        "./src/index.mts"
-      ],
-      "import": "./lib/index.mjs",
-      "require": "./lib/index.js",
-      "default": "./lib/index.js"
-    },
-    "./*": "./*"
-  },
+  "type": "commonjs",
   "scripts": {
-    "build-tsc": "node ../../../scripts/build-tsc.mjs"
+    "check-ts": "tsc --noEmit"
   },
-  "gitHead": "6de04fbaeccfba1e7832c737f6318cbd603fc74d"
+  "types": "src/index.ts",
+  "gitHead": "08dcc1c9bcdc6ab931d55e05ccc0f45669de2f22"
 }

package/src/{Disposable.mts → Disposable.ts}

@@ -1,9 +1,9 @@
-import type {IDisposable} from './types.mts';
+import type {IDisposable} from './types';
 
 import invariant from 'assert';
-import {AlreadyDisposedError} from './errors.mts';
+import {AlreadyDisposedError} from './errors';
 
-type DisposableLike = IDisposable | (() => (any | Promise<any>));
+type DisposableLike = IDisposable | (() => unknown);
 
 /*
  * A general-purpose disposable class. It can normalize disposable-like values
@@ -12,7 +12,7 @@ type DisposableLike = IDisposable | (() => (any | Promise<any>));
  */
 export default class Disposable implements IDisposable {
   disposed: boolean = false;
-  #disposables: Set<DisposableLike> | null;
+  #disposables: Set<DisposableLike> | null | undefined;
 
   constructor(...disposables: Array<DisposableLike>) {
     this.#disposables = new Set(disposables);

package/src/{ValueEmitter.mts → ValueEmitter.ts}

@@ -1,6 +1,6 @@
-import type {IDisposable} from './types.mts';
+import type {IDisposable} from './types';
 
-import {AlreadyDisposedError} from './errors.mts';
+import {AlreadyDisposedError} from './errors';
 
 // Like an EventEmitter, but for only a single "event". This provides type-safety
 // for the values emitted. Rather than passing predetermined strings (which can
@@ -10,10 +10,10 @@ export default class ValueEmitter<TValue> implements IDisposable {
   // An array of listeners. One might think a Set would be better for O(1) removal,
   // but splicing a JS array gets pretty close, and copying the array (as is done
   // in emit) is far faster than a Set copy: https://github.com/atom/event-kit/pull/39
-  _listeners: Array<(value: TValue) => (any | Promise<any>)> = [];
+  _listeners: Array<(value: TValue) => unknown> = [];
   _disposed: boolean = false;
 
-  addListener(listener: (value: TValue) => (any | Promise<any>)): IDisposable {
+  addListener(listener: (value: TValue) => unknown): IDisposable {
     if (this._disposed) {
       throw new AlreadyDisposedError(
         'Cannot add a listener since this ValueEmitter has been disposed',
@@ -27,7 +27,7 @@ export default class ValueEmitter<TValue> implements IDisposable {
     // slicing out the listener.
     // This prevents anyone holding onto the disposable after disposal from
     // unintentionally retaining a reference to this emitter.
-    let emitter: typeof this | null = this;
+    let emitter = this;
     return {
       dispose() {
         if (emitter == null) {
@@ -35,6 +35,7 @@ export default class ValueEmitter<TValue> implements IDisposable {
         }
 
         if (emitter._disposed) {
+          // @ts-expect-error - Setting emitter to null to prevent memory leaks
           emitter = null;
           return;
         }
@@ -45,6 +46,7 @@ export default class ValueEmitter<TValue> implements IDisposable {
           listeners.splice(listenerIndex, 1);
         }
 
+        // @ts-expect-error - Setting emitter to null to prevent memory leaks
         emitter = null;
       },
     };
@@ -68,7 +70,7 @@ export default class ValueEmitter<TValue> implements IDisposable {
     }
   }
 
-  dispose(): void {
+  dispose() {
     if (this._disposed) {
       return;
     }

package/src/index.ts

@@ -0,0 +1,3 @@
+export {default as Disposable} from './Disposable';
+export {default as ValueEmitter} from './ValueEmitter';
+export {AlreadyDisposedError} from './errors';

package/src/{types.mts → types.ts}

@@ -2,5 +2,5 @@ export interface IDisposable {
   /** This can return a Promise, as dispose() of all inner disposables are
    * awaited in Disposable#dispose()
    */
-  dispose(): (any | Promise<any>);
+  dispose(): unknown;
 }

package/test/{Disposable.test.mts → Disposable.test.ts}

@@ -1,10 +1,10 @@
 import assert from 'assert';
-import Disposable from '../src/Disposable.mts';
-import {AlreadyDisposedError} from '../src/errors.mts';
+import Disposable from '../src/Disposable';
+import {AlreadyDisposedError} from '../src/errors';
 
 describe('Disposable', () => {
   it('can wrap an IDisposable', () => {
-    let disposed;
+    let disposed: any;
 
     new Disposable({
       dispose() {
@@ -15,7 +15,7 @@ describe('Disposable', () => {
   });
 
   it('can wrap a function to dispose', () => {
-    let disposed;
+    let disposed: any;
     new Disposable(() => {
       disposed = true;
     }).dispose();
@@ -23,8 +23,8 @@ describe('Disposable', () => {
   });
 
   it('can wrap many disposable-likes', () => {
-    let disposed1;
-    let disposed2;
+    let disposed1: any;
+    let disposed2: any;
 
     new Disposable(
       {
@@ -41,10 +41,10 @@ describe('Disposable', () => {
   });
 
   it('can add disposables after construction', () => {
-    let disposed1;
-    let disposed2;
-    let disposed3;
-    let disposed4;
+    let disposed1: any;
+    let disposed2: any;
+    let disposed3: any;
+    let disposed4: any;
 
     let disposable = new Disposable(
       {
@@ -85,10 +85,9 @@ describe('Disposable', () => {
     'does not dispose inner disposables more than once,' +
       ' and does not throw on subsequent disposals',
     () => {
-      let disposed: Disposable | boolean;
+      let disposed: any;
       let disposable = new Disposable(() => {
         if (disposed) {
-          // $FlowFixMe
           assert.fail();
         }
         disposed = true;

package/test/{ValueEmitter.test.mts → ValueEmitter.test.ts}

@@ -1,7 +1,6 @@
 import assert from 'assert';
-import ValueEmitter from '../src/ValueEmitter.mts';
-import {AlreadyDisposedError} from '../src/errors.mts';
-import type { IDisposable } from '../src/types.mts';
+import ValueEmitter from '../src/ValueEmitter';
+import {AlreadyDisposedError} from '../src/errors';
 
 describe('ValueEmitter', () => {
   let emitter: ValueEmitter<number>;
@@ -37,7 +36,7 @@ describe('ValueEmitter', () => {
   });
 
   it('does not emit to listeners that were just registered', () => {
-    let innerDisposable: IDisposable | undefined;
+    let innerDisposable: any;
     let disposable = emitter.addListener(() => {
       innerDisposable = emitter.addListener(numberListener);
     });

package/lib/Disposable.d.mts

@@ -1,10 +0,0 @@
-import type { IDisposable } from './types.mts';
-type DisposableLike = IDisposable | (() => (any | Promise<any>));
-export default class Disposable implements IDisposable {
-    #private;
-    disposed: boolean;
-    constructor(...disposables: Array<DisposableLike>);
-    add(...disposables: Array<DisposableLike>): void;
-    dispose(): Promise<void>;
-}
-export {};

package/lib/Disposable.mjs

@@ -1,32 +0,0 @@
-import invariant from 'assert';
-import { AlreadyDisposedError } from "./errors.mjs";
-/*
- * A general-purpose disposable class. It can normalize disposable-like values
- * (such as single functions or IDisposables), as well as hold multiple
- * disposable-like values to be disposed of at once.
- */
-export default class Disposable {
-    disposed = false;
-    #disposables;
-    constructor(...disposables) {
-        this.#disposables = new Set(disposables);
-    }
-    add(...disposables) {
-        if (this.disposed) {
-            throw new AlreadyDisposedError('Cannot add new disposables after disposable has been disposed');
-        }
-        invariant(this.#disposables != null);
-        for (let disposable of disposables) {
-            this.#disposables.add(disposable);
-        }
-    }
-    async dispose() {
-        if (this.disposed) {
-            return;
-        }
-        this.disposed = true;
-        invariant(this.#disposables != null);
-        await Promise.all([...this.#disposables].map((disposable) => typeof disposable === 'function' ? disposable() : disposable.dispose()));
-        this.#disposables = null;
-    }
-}

package/lib/ValueEmitter.d.mts

@@ -1,8 +0,0 @@
-import type { IDisposable } from './types.mts';
-export default class ValueEmitter<TValue> implements IDisposable {
-    _listeners: Array<(value: TValue) => (any | Promise<any>)>;
-    _disposed: boolean;
-    addListener(listener: (value: TValue) => (any | Promise<any>)): IDisposable;
-    emit(value: TValue): void;
-    dispose(): void;
-}

package/lib/ValueEmitter.mjs

@@ -1,62 +0,0 @@
-import { AlreadyDisposedError } from "./errors.mjs";
-// Like an EventEmitter, but for only a single "event". This provides type-safety
-// for the values emitted. Rather than passing predetermined strings (which can
-// be misspelled), create an instance of ValueEmitter for every logical "event"
-// to be dispatched, and type it according to the type of value emitted.
-export default class ValueEmitter {
-    // An array of listeners. One might think a Set would be better for O(1) removal,
-    // but splicing a JS array gets pretty close, and copying the array (as is done
-    // in emit) is far faster than a Set copy: https://github.com/atom/event-kit/pull/39
-    _listeners = [];
-    _disposed = false;
-    addListener(listener) {
-        if (this._disposed) {
-            throw new AlreadyDisposedError('Cannot add a listener since this ValueEmitter has been disposed');
-        }
-        this._listeners.push(listener);
-        // Close over a reference to this emitter in the disposable below, rather
-        // than referencing `this` directly. This allows us to set it to null after
-        // slicing out the listener.
-        // This prevents anyone holding onto the disposable after disposal from
-        // unintentionally retaining a reference to this emitter.
-        let emitter = this;
-        return {
-            dispose() {
-                if (emitter == null) {
-                    return;
-                }
-                if (emitter._disposed) {
-                    emitter = null;
-                    return;
-                }
-                let listeners = emitter._listeners;
-                let listenerIndex = listeners.indexOf(listener);
-                if (listenerIndex > -1) {
-                    listeners.splice(listenerIndex, 1);
-                }
-                emitter = null;
-            },
-        };
-    }
-    emit(value) {
-        if (this._disposed) {
-            throw new AlreadyDisposedError('Cannot emit since this ValueEmitter has been disposed');
-        }
-        // Iterate over a copy of listeners. This prevents the following cases:
-        // * When a listener callback can itself register a new listener and be
-        //   emitted as part of this iteration.
-        // * When a listener callback disposes of this emitter mid-emit, preventing
-        //   other listeners from receiving the event.
-        let listeners = this._listeners.slice();
-        for (let i = 0; i < listeners.length; i++) {
-            listeners[i](value);
-        }
-    }
-    dispose() {
-        if (this._disposed) {
-            return;
-        }
-        this._listeners = [];
-        this._disposed = true;
-    }
-}

package/lib/errors.d.mts

@@ -1,2 +0,0 @@
-export declare class AlreadyDisposedError extends Error {
-}

package/lib/errors.mjs

@@ -1,5 +0,0 @@
-export class AlreadyDisposedError extends Error {
-}
-Object.defineProperty(AlreadyDisposedError.prototype, 'name', {
-    value: 'AlreadyDisposedError',
-});

package/lib/index.d.mts

@@ -1,3 +0,0 @@
-export { default as Disposable } from './Disposable.mts';
-export { default as ValueEmitter } from './ValueEmitter.mts';
-export { AlreadyDisposedError } from './errors.mts';

package/lib/index.js.flow

@@ -1,26 +0,0 @@
-// @flow
-
-export interface IDisposable {
-  /** This can return a Promise, as dispose() of all inner disposables are
-   * awaited in Disposable#dispose()
-   */
-  dispose(): mixed;
-}
-
-export type DisposableLike = IDisposable | (() => mixed);
-
-declare export class Disposable implements IDisposable {
-  disposed: boolean;
-  add(...disposables: Array<DisposableLike>): void;
-  dispose(): Promise<void> ;
-}
-
-declare export class AlreadyDisposedError extends Error {
-  name: string
-}
-
-declare export class ValueEmitter<TValue> implements IDisposable {
-  addListener(listener: (value: TValue) => mixed): IDisposable;
-  emit(value: TValue): void;
-  dispose(): void;
-}

package/lib/index.mjs

@@ -1,3 +0,0 @@
-export { default as Disposable } from "./Disposable.mjs";
-export { default as ValueEmitter } from "./ValueEmitter.mjs";
-export { AlreadyDisposedError } from "./errors.mjs";

package/lib/types.d.mts

@@ -1,6 +0,0 @@
-export interface IDisposable {
-    /** This can return a Promise, as dispose() of all inner disposables are
-     * awaited in Disposable#dispose()
-     */
-    dispose(): (any | Promise<any>);
-}

package/lib/types.mjs

@@ -1 +0,0 @@
-export {};

package/src/index.mts

@@ -1,3 +0,0 @@
-export {default as Disposable} from './Disposable.mts';
-export {default as ValueEmitter} from './ValueEmitter.mts';
-export {AlreadyDisposedError} from './errors.mts';