@mongodb-js/compass-utils 0.10.5 → 0.10.7

package/dist/.esm-wrapper.mjs

@@ -3,10 +3,17 @@ import mod from "./index.js";
 export default mod;
 export const cancellableWait = mod.cancellableWait;
 export const createCancelError = mod.createCancelError;
+export const errorFromEvent = mod.errorFromEvent;
 export const getAppName = mod.getAppName;
 export const getAppVersion = mod.getAppVersion;
 export const getStoragePath = mod.getStoragePath;
 export const isCancelError = mod.isCancelError;
+export const isUtilityPortChannel = mod.isUtilityPortChannel;
+export const listen = mod.listen;
+export const once = mod.once;
+export const openUtilityPort = mod.openUtilityPort;
 export const promisifyAmpersandMethod = mod.promisifyAmpersandMethod;
 export const raceWithAbort = mod.raceWithAbort;
 export const throwIfAborted = mod.throwIfAborted;
+export const utilityPortChannel = mod.utilityPortChannel;
+export const waitUntil = mod.waitUntil;

package/dist/events.d.ts

@@ -0,0 +1,34 @@
+import type { EventEmitter } from 'node:events';
+export type EventSource = Pick<EventTarget, 'addEventListener' | 'removeEventListener'> | Pick<EventEmitter, 'once' | 'on' | 'off'>;
+/**
+ * Adds `listener` and returns a Disposable that removes it, so callers can use
+ * `using` or a DisposableStack instead of keeping track of the listener. Works
+ * with DOM EventTargets and Node.js-style emitters (EventEmitter, Electron's
+ * MessagePortMain and parentPort): `listener` gets the event for the former
+ * and the emitted arguments for the latter. With `once`, the listener is
+ * removed after it first runs.
+ */
+export declare function listen<Args extends unknown[]>(es: EventSource, event: string, listener: (...args: Args) => void, { once }?: {
+    once?: boolean;
+}): Disposable;
+/**
+ * Resolves with the arguments of the next `event`, like Node.js's
+ * `events.once`, for both kinds of target. Rejects if `signal` aborts.
+ */
+export declare function once<Args extends unknown[]>(es: EventSource, event: string, { signal }?: {
+    signal?: AbortSignal;
+}): Promise<Args>;
+/**
+ * Resolves with the arguments of the first `event` that `filter` accepts.
+ * `filter` may throw to reject instead, e.g. when an error message arrives.
+ */
+export declare function waitUntil<Args extends unknown[] = unknown[]>(es: EventSource, event: string, filter: (...args: Args) => boolean, { signal }?: {
+    signal?: AbortSignal;
+}): Promise<Args>;
+/**
+ * The Error behind an `error` event. A DOM ErrorEvent carries it on `.error`;
+ * Node-style emitters and libraries like web-worker dispatch the Error itself.
+ * Falls back to an Error built from the event's message.
+ */
+export declare function errorFromEvent(event: unknown): Error;
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,MAAM,WAAW,GACnB,IAAI,CAAC,WAAW,EAAE,kBAAkB,GAAG,qBAAqB,CAAC,GAC7D,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC;AAyC9C;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,IAAI,SAAS,OAAO,EAAE,EAC3C,EAAE,EAAE,WAAW,EACf,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,IAAI,EACjC,EAAE,IAAY,EAAE,GAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAO,GACxC,UAAU,CAMZ;AASD;;;GAGG;AACH,wBAAsB,IAAI,CAAC,IAAI,SAAS,OAAO,EAAE,EAC/C,EAAE,EAAE,WAAW,EACf,KAAK,EAAE,MAAM,EACb,EAAE,MAAM,EAAE,GAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAO,GACxC,OAAO,CAAC,IAAI,CAAC,CAQf;AAED;;;GAGG;AACH,wBAAsB,SAAS,CAAC,IAAI,SAAS,OAAO,EAAE,GAAG,OAAO,EAAE,EAChE,EAAE,EAAE,WAAW,EACf,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,OAAO,EAClC,EAAE,MAAM,EAAE,GAAE;IAAE,MAAM,CAAC,EAAE,WAAW,CAAA;CAAO,GACxC,OAAO,CAAC,IAAI,CAAC,CAoBf;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAOpD"}

package/dist/events.js

@@ -0,0 +1,173 @@
+"use strict";
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listen = listen;
+exports.once = once;
+exports.waitUntil = waitUntil;
+exports.errorFromEvent = errorFromEvent;
+function isEventTarget(et) {
+    return (!!et &&
+        typeof et === 'object' &&
+        'addEventListener' in et &&
+        typeof et.addEventListener === 'function');
+}
+function addListener(es, event, listener, { once = false } = {}) {
+    if (isEventTarget(es)) {
+        es.addEventListener(event, listener, { once });
+        return;
+    }
+    if (once) {
+        es.once(event, listener);
+    }
+    else {
+        es.on(event, listener);
+    }
+}
+function removeListener(es, event, listener) {
+    if (isEventTarget(es)) {
+        es.removeEventListener(event, listener);
+        return;
+    }
+    es.off(event, listener);
+}
+/**
+ * Adds `listener` and returns a Disposable that removes it, so callers can use
+ * `using` or a DisposableStack instead of keeping track of the listener. Works
+ * with DOM EventTargets and Node.js-style emitters (EventEmitter, Electron's
+ * MessagePortMain and parentPort): `listener` gets the event for the former
+ * and the emitted arguments for the latter. With `once`, the listener is
+ * removed after it first runs.
+ */
+function listen(es, event, listener, { once = false } = {}) {
+    addListener(es, event, listener, { once });
+    return {
+        [Symbol.dispose]: () => removeListener(es, event, listener),
+    };
+}
+function rejectOnAbort(signal, reject) {
+    return signal && listen(signal, 'abort', () => reject(signal.reason));
+}
+/**
+ * Resolves with the arguments of the next `event`, like Node.js's
+ * `events.once`, for both kinds of target. Rejects if `signal` aborts.
+ */
+async function once(es, event, { signal } = {}) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        signal?.throwIfAborted();
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const _listener = __addDisposableResource(env_1, listen(es, event, (...args) => resolve(args), {
+            once: true,
+        }), false);
+        const _abort = __addDisposableResource(env_1, rejectOnAbort(signal, reject), false);
+        return await promise;
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+}
+/**
+ * Resolves with the arguments of the first `event` that `filter` accepts.
+ * `filter` may throw to reject instead, e.g. when an error message arrives.
+ */
+async function waitUntil(es, event, filter, { signal } = {}) {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        signal?.throwIfAborted();
+        const { promise, resolve, reject } = Promise.withResolvers();
+        // Stop listening inside the listener: an emitter can emit again before any
+        // promise callback runs, and `filter` must not see those events.
+        const waiter = __addDisposableResource(env_2, listen(es, event, (...args) => {
+            try {
+                if (!filter(...args))
+                    return;
+                waiter[Symbol.dispose]();
+                resolve(args);
+            }
+            catch (error) {
+                waiter[Symbol.dispose]();
+                reject(error);
+            }
+        }), false);
+        const _abort = __addDisposableResource(env_2, rejectOnAbort(signal, (error) => {
+            waiter[Symbol.dispose]();
+            reject(error);
+        }), false);
+        return await promise;
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        __disposeResources(env_2);
+    }
+}
+/**
+ * The Error behind an `error` event. A DOM ErrorEvent carries it on `.error`;
+ * Node-style emitters and libraries like web-worker dispatch the Error itself.
+ * Falls back to an Error built from the event's message.
+ */
+function errorFromEvent(event) {
+    if (event instanceof Error)
+        return event;
+    const { error, message } = (event ?? {});
+    if (error instanceof Error)
+        return error;
+    return new Error(typeof message === 'string' ? message : `Unknown error: ${String(message)}`);
+}

package/dist/index.d.ts

@@ -2,4 +2,7 @@ export type { AmpersandMethodOptions } from './promisify-ampersand-method';
 export { promisifyAmpersandMethod } from './promisify-ampersand-method';
 export { getAppName, getStoragePath, getAppVersion } from './electron';
 export { raceWithAbort, cancellableWait, createCancelError, isCancelError, throwIfAborted, } from './cancellable-promise';
+export { utilityPortChannel, isUtilityPortChannel, openUtilityPort, } from './utility-process';
+export { errorFromEvent, listen, once, waitUntil } from './events';
+export type { EventSource } from './events';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EACL,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,cAAc,GACf,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EACL,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,cAAc,GACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,GAChB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACnE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.throwIfAborted = exports.isCancelError = exports.createCancelError = exports.cancellableWait = exports.raceWithAbort = exports.getAppVersion = exports.getStoragePath = exports.getAppName = exports.promisifyAmpersandMethod = void 0;
+exports.waitUntil = exports.once = exports.listen = exports.errorFromEvent = exports.openUtilityPort = exports.isUtilityPortChannel = exports.utilityPortChannel = exports.throwIfAborted = exports.isCancelError = exports.createCancelError = exports.cancellableWait = exports.raceWithAbort = exports.getAppVersion = exports.getStoragePath = exports.getAppName = exports.promisifyAmpersandMethod = void 0;
 var promisify_ampersand_method_1 = require("./promisify-ampersand-method");
 Object.defineProperty(exports, "promisifyAmpersandMethod", { enumerable: true, get: function () { return promisify_ampersand_method_1.promisifyAmpersandMethod; } });
 var electron_1 = require("./electron");
@@ -13,3 +13,12 @@ Object.defineProperty(exports, "cancellableWait", { enumerable: true, get: funct
 Object.defineProperty(exports, "createCancelError", { enumerable: true, get: function () { return cancellable_promise_1.createCancelError; } });
 Object.defineProperty(exports, "isCancelError", { enumerable: true, get: function () { return cancellable_promise_1.isCancelError; } });
 Object.defineProperty(exports, "throwIfAborted", { enumerable: true, get: function () { return cancellable_promise_1.throwIfAborted; } });
+var utility_process_1 = require("./utility-process");
+Object.defineProperty(exports, "utilityPortChannel", { enumerable: true, get: function () { return utility_process_1.utilityPortChannel; } });
+Object.defineProperty(exports, "isUtilityPortChannel", { enumerable: true, get: function () { return utility_process_1.isUtilityPortChannel; } });
+Object.defineProperty(exports, "openUtilityPort", { enumerable: true, get: function () { return utility_process_1.openUtilityPort; } });
+var events_1 = require("./events");
+Object.defineProperty(exports, "errorFromEvent", { enumerable: true, get: function () { return events_1.errorFromEvent; } });
+Object.defineProperty(exports, "listen", { enumerable: true, get: function () { return events_1.listen; } });
+Object.defineProperty(exports, "once", { enumerable: true, get: function () { return events_1.once; } });
+Object.defineProperty(exports, "waitUntil", { enumerable: true, get: function () { return events_1.waitUntil; } });

package/dist/utility-process.d.ts

@@ -0,0 +1,16 @@
+/**
+ * How renderer code reaches a utility process. Everything follows from the
+ * utility's name, which is its directory under packages/compass/src/utilities.
+ */
+/**
+ * Channel name the renderer posts its end of a MessageChannel on for the utility to pickup.
+ */
+export declare function utilityPortChannel(name: string): string;
+/** Whether `channel` is one `utilityPortChannel` produces, for any utility. */
+export declare function isUtilityPortChannel(channel: unknown): channel is `compass:utility:${string}:port`;
+/**
+ * Opens a channel to the named utility. The preload script forwards the other
+ * end to main, which hands it to the utility.
+ */
+export declare function openUtilityPort(name: string): MessagePort;
+//# sourceMappingURL=utility-process.d.ts.map

package/dist/utility-process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility-process.d.ts","sourceRoot":"","sources":["../src/utility-process.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,+EAA+E;AAC/E,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,OAAO,GACf,OAAO,IAAI,mBAAmB,MAAM,OAAO,CAI7C;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAIzD"}

package/dist/utility-process.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * How renderer code reaches a utility process. Everything follows from the
+ * utility's name, which is its directory under packages/compass/src/utilities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utilityPortChannel = utilityPortChannel;
+exports.isUtilityPortChannel = isUtilityPortChannel;
+exports.openUtilityPort = openUtilityPort;
+/**
+ * Channel name the renderer posts its end of a MessageChannel on for the utility to pickup.
+ */
+function utilityPortChannel(name) {
+    return `compass:utility:${name}:port`;
+}
+/** Whether `channel` is one `utilityPortChannel` produces, for any utility. */
+function isUtilityPortChannel(channel) {
+    return (typeof channel === 'string' && /^compass:utility:[^:]+:port$/.test(channel));
+}
+/**
+ * Opens a channel to the named utility. The preload script forwards the other
+ * end to main, which hands it to the utility.
+ */
+function openUtilityPort(name) {
+    const { port1, port2 } = new MessageChannel();
+    window.postMessage({ type: utilityPortChannel(name) }, '*', [port2]);
+    return port1;
+}

package/package.json

@@ -13,7 +13,7 @@
     "email": "compass@mongodb.com"
   },
   "homepage": "https://github.com/mongodb-js/compass",
-  "version": "0.10.5",
+  "version": "0.10.7",
   "repository": {
     "type": "git",
     "url": "https://github.com/mongodb-js/compass.git"
@@ -50,10 +50,10 @@
     "reformat": "npm run eslint . -- --fix && npm run prettier -- --write ."
   },
   "devDependencies": {
-    "@mongodb-js/eslint-config-compass": "^1.4.28",
-    "@mongodb-js/mocha-config-compass": "^1.8.1",
-    "@mongodb-js/prettier-config-compass": "^1.2.9",
-    "@mongodb-js/tsconfig-compass": "^1.3.1",
+    "@mongodb-js/eslint-config-compass": "^1.4.30",
+    "@mongodb-js/mocha-config-compass": "^1.8.2",
+    "@mongodb-js/prettier-config-compass": "^1.2.10",
+    "@mongodb-js/tsconfig-compass": "^1.3.2",
     "@types/chai": "^4.2.21",
     "@types/mocha": "^9.0.0",
     "@types/sinon-chai": "^3.2.5",
@@ -67,7 +67,7 @@
   },
   "dependencies": {
     "@electron/remote": "^2.1.3",
-    "electron": "^44.5.0"
+    "electron": "^45.0.0"
   },
-  "gitHead": "ef7b44ec5ff794f83d167daa4146b0bdcab5e0a3"
+  "gitHead": "ba44a9dbfe032bf5acb4b6daac0718fbc96892c0"
 }