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

package/lib/Disposable.d.mts

@@ -0,0 +1,10 @@
+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.js

@@ -1,47 +1,48 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-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 }; }
-/*
+Object.defineProperty(exports, /*
  * 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 /*: ?Set<DisposableLike> */;
-
-  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');
+    disposed = false;
+    #disposables;
+    constructor(...disposables){
+        this.#disposables = new Set(disposables);
     }
-    (0, _assert().default)(this.#disposables != null);
-    for (let disposable of disposables) {
-      this.#disposables.add(disposable);
+    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);
+        }
     }
-  }
-  async dispose() {
-    if (this.disposed) {
-      return;
+    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;
     }
-    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/Disposable.mjs

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,8 @@
+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.js

@@ -1,71 +1,72 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-exports.default = void 0;
-var _errors = require("./errors");
-// Like an EventEmitter, but for only a single "event". This provides type-safety
+Object.defineProperty(exports, // 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.
-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');
+"default", {
+    enumerable: true,
+    get: function() {
+        return ValueEmitter;
     }
-    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;
+});
+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');
         }
-        if (emitter._disposed) {
-          emitter = null;
-          return;
+        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 _errors.AlreadyDisposedError('Cannot emit since this ValueEmitter has been disposed');
         }
-        let listeners = emitter._listeners;
-        let listenerIndex = listeners.indexOf(listener);
-        if (listenerIndex > -1) {
-          listeners.splice(listenerIndex, 1);
+        // 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);
         }
-        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;
+    dispose() {
+        if (this._disposed) {
+            return;
+        }
+        this._listeners = [];
+        this._disposed = true;
     }
-    this._listeners = [];
-    this._disposed = true;
-  }
 }
-exports.default = ValueEmitter;

package/lib/ValueEmitter.mjs

@@ -0,0 +1,62 @@
+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

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

package/lib/errors.js

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

package/lib/errors.mjs

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

package/lib/index.d.mts

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

package/lib/index.js

@@ -1,27 +1,29 @@
 "use strict";
-
 Object.defineProperty(exports, "__esModule", {
-  value: true
+    value: true
 });
-Object.defineProperty(exports, "AlreadyDisposedError", {
-  enumerable: true,
-  get: function () {
-    return _errors.AlreadyDisposedError;
-  }
+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, "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 }; }
+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
+    };
+}

package/lib/index.js.flow

@@ -0,0 +1,26 @@
+// @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

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

package/lib/types.d.mts

@@ -0,0 +1,6 @@
+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.js

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

package/lib/types.mjs

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

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@atlaspack/events",
-  "version": "2.14.2-typescript-e769947a5.0",
+  "version": "2.14.2-typescript-6de04fbae.0",
   "license": "(MIT OR Apache-2.0)",
+  "type": "commonjs",
   "publishConfig": {
     "access": "public"
   },
@@ -10,10 +11,25 @@
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
   "main": "lib/index.js",
-  "source": "src/index.js",
+  "types": "lib/index.d.mts",
   "engines": {
     "node": ">= 16.0.0"
   },
-  "type": "commonjs",
-  "gitHead": "e769947a5b0c22d9477211ac1ce6614e6bf9def3"
+  "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"
+    },
+    "./*": "./*"
+  },
+  "scripts": {
+    "build-tsc": "node ../../../scripts/build-tsc.mjs"
+  },
+  "gitHead": "6de04fbaeccfba1e7832c737f6318cbd603fc74d"
 }

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

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

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

@@ -1,8 +1,6 @@
-// @flow strict-local
+import type {IDisposable} from './types.mts';
 
-import type {IDisposable} from './types';
-
-import {AlreadyDisposedError} from './errors';
+import {AlreadyDisposedError} from './errors.mts';
 
 // Like an EventEmitter, but for only a single "event". This provides type-safety
 // for the values emitted. Rather than passing predetermined strings (which can
@@ -12,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) => mixed> = [];
+  _listeners: Array<(value: TValue) => (any | Promise<any>)> = [];
   _disposed: boolean = false;
 
-  addListener(listener: (value: TValue) => mixed): IDisposable {
+  addListener(listener: (value: TValue) => (any | Promise<any>)): IDisposable {
     if (this._disposed) {
       throw new AlreadyDisposedError(
         'Cannot add a listener since this ValueEmitter has been disposed',
@@ -29,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 = this;
+    let emitter: typeof this | null = this;
     return {
       dispose() {
         if (emitter == null) {
@@ -70,7 +68,7 @@ export default class ValueEmitter<TValue> implements IDisposable {
     }
   }
 
-  dispose() {
+  dispose(): void {
     if (this._disposed) {
       return;
     }

package/src/{errors.js → errors.mts}

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 export class AlreadyDisposedError extends Error {}
 Object.defineProperty(AlreadyDisposedError.prototype, 'name', {
   value: 'AlreadyDisposedError',

package/src/index.mts

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

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

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

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

@@ -1,8 +1,6 @@
-// @flow strict-local
-
 import assert from 'assert';
-import Disposable from '../src/Disposable';
-import {AlreadyDisposedError} from '../src/errors';
+import Disposable from '../src/Disposable.mts';
+import {AlreadyDisposedError} from '../src/errors.mts';
 
 describe('Disposable', () => {
   it('can wrap an IDisposable', () => {
@@ -87,7 +85,7 @@ describe('Disposable', () => {
     'does not dispose inner disposables more than once,' +
       ' and does not throw on subsequent disposals',
     () => {
-      let disposed;
+      let disposed: Disposable | boolean;
       let disposable = new Disposable(() => {
         if (disposed) {
           // $FlowFixMe

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

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

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../tsconfig.json",
+  "include": ["src"]
+}

package/src/index.js

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