penpal 7.0.0-beta.2 → 7.0.0-beta.4

package/README.md

@@ -27,13 +27,13 @@
 
 Install Penpal from npm as follows:
 
-`npm install penpal`
+`npm install penpal@next`
 
 ### Using a CDN
 
 Alternatively, load a build of Penpal that is already hosted on a CDN:
 
-`<script src="https://unpkg.com/penpal@^7/dist/penpal.min.js"></script>`
+`<script src="https://unpkg.com/penpal@next/dist/penpal.min.js"></script>`
 
 Penpal will then be installed on `window.Penpal`. Usage is similar to if you were using it from npm, which is documented below, but instead of importing each module, you would access it on the `Penpal` global variable instead.
 
@@ -267,7 +267,7 @@ console.log(additionResult); // 8
 ### Window
 
 ```javascript
-import { WorkerMessenger, connect } from 'penpal';
+import { PortMessenger, connect } from 'penpal';
 
 const worker = new SharedWorker('shared-worker.js');
 
@@ -345,6 +345,16 @@ import { PortMessenger, connect } from 'penpal';
 const initPenpal = async () => {
   const { port1, port2 } = new MessageChannel();
 
+  navigator.serviceWorker.controller?.postMessage(
+    {
+      type: 'INIT_PENPAL',
+      port: port2,
+    },
+    {
+      transfer: [port2],
+    }
+  );
+
   const messenger = new PortMessenger({
     port: port1,
   });
@@ -365,16 +375,6 @@ const initPenpal = async () => {
   console.log(multiplicationResult); // 12
   const divisionResult = await remote.divide(12, 4);
   console.log(divisionResult); // 3
-
-  navigator.serviceWorker.controller?.postMessage(
-    {
-      type: 'INIT_PENPAL',
-      port: port2,
-    },
-    {
-      transfer: [port2],
-    }
-  );
 };
 
 if (navigator.serviceWorker.controller) {
@@ -566,13 +566,13 @@ const connection = connect({
 
 ## Parallel Connections
 
-In fairly rare cases, you may wish to make parallel connections between two participants. To illustrate, let's use a scenario where you wish to make two parallel connections between Window A and Window B. In other words, you will be calling `connect()` twice within Window A and twice within Window B.
+In fairly rare cases, you may wish to make parallel connections between two participants. To illustrate, let's use a scenario where you wish to make two parallel connections between a parent window and an iframe window. In other words, you will be calling `connect()` twice within the parent window and twice within the iframe window.
 
-In an attempt to establish these two connections, Penpal in Window A will be calling `postMessage()` on a single window object. By default, when Penpal within Window B receives these messages, it has no way to disambiguate messages related to the first call to `connect()` from messages related to the second call to `connect()`. As a result, the connections may fail to be properly established.
+In an attempt to establish these two connections, Penpal in the parent window will be calling `postMessage()` on the iframe's window object (`iframe.contentWindow`). By default, when Penpal within the iframe window receives these messages, it has no way to disambiguate messages related to the parent window's first call to `connect()` from messages related to the parent window's second call to `connect()`. As a result, the connections may fail to be properly established.
 
 To prevent this issue, Penpal provides the concept of channels. A channel is a string identifier of your choosing that you may provide when calling `connect()` within both participants. When a channel is provided, it is used to disambiguate communication between parallel connections. This is better explained in code:
 
-### Window A
+### Parent Window
 
 ```javascript
 import { WindowMessenger, connect } from 'penpal';
@@ -613,14 +613,14 @@ const connectionB = connect({
 });
 ```
 
-### Window B
+### Iframe Window
 
 ```javascript
 import { WindowMessenger, connect } from 'penpal';
 
 const messengerA = new WindowMessenger({
   remoteWindow: window.parent,
-  allowedOrigins: ['https://parentOrigin.example.com'],
+  allowedOrigins: ['https://parentorigin.example.com'],
 });
 
 const connectionA = connect({
@@ -650,7 +650,7 @@ const connectionB = connect({
 });
 ```
 
-Although we're using `WindowMessenger` here to establish connections between two windows, channels would similarly need to be used when using `WorkerMessenger` to make parallel connections to a worker. When using `PortMessenger`, channels are only needed when establishing parallel connections over a single pair of ports.
+Although we're using `WindowMessenger` here to connect between a parent window and an iframe window, channels would similarly need to be used when using `WorkerMessenger` to make parallel connections to a worker. When using `PortMessenger`, channels are only needed when establishing parallel connections over a single pair of ports.
 
 ## Errors
 
@@ -680,7 +680,7 @@ The promise returned from a method call will be rejected with this error if the
 
 When a connection is being established, the promise found at `connection.promise` will be rejected with this error if a message cannot be transmitted. When a method call is being made, the promise returned from the method call will be rejected with this error if a message cannot be transmitted.
 
-### Error Code Enumeration
+### Referencing Error Codes
 
 For your convenience, the above error codes can be imported and referenced as follows:
 
@@ -725,6 +725,14 @@ const remote = await connection.promise;
 const multiplicationResult = await remote.multiply(2, 6);
 ```
 
+When creating a worker, it's highly recommended that you add the following line of code at the top of your worker script depending on which type of worker you're creating:
+
+- Dedicated (regular) worker: `declare const self: DedicatedWorkerGlobalScope;`
+- Shared worker: `declare const self: SharedWorkerGlobalScope;`
+- Service worker: `declare const self: ServiceWorkerGlobalScope;`
+
+This lets TypeScript know which type of worker you're creating, and you'll run into fewer TypeScript errors.
+
 ### Exported Types
 
 Penpal exports several types for your usage. Import types as follows:

package/cjs/CallOptions.d.ts

@@ -1,8 +1,7 @@
-declare const brand: unique symbol;
 declare class CallOptions {
+    #private;
     readonly transferables?: Transferable[];
     readonly timeout?: number;
-    private [brand];
     constructor(options?: {
         transferables?: Transferable[];
         timeout?: number;

package/cjs/CallOptions.js

@@ -6,7 +6,8 @@ class CallOptions {
     timeout;
     // Allows TypeScript to distinguish between an actual instance of this
     // class versus an object that looks structurally similar.
-    [brand] = brand;
+    // eslint-disable-next-line no-unused-private-class-members
+    #brand = brand;
     constructor(options) {
         this.transferables = options?.transferables;
         this.timeout = options?.timeout;

package/cjs/ErrorCodeObj.d.ts

@@ -0,0 +1,9 @@
+declare const ErrorCodeObj: {
+    readonly ConnectionDestroyed: "CONNECTION_DESTROYED";
+    readonly ConnectionTimeout: "CONNECTION_TIMEOUT";
+    readonly InvalidArgument: "INVALID_ARGUMENT";
+    readonly MethodCallTimeout: "METHOD_CALL_TIMEOUT";
+    readonly MethodNotFound: "METHOD_NOT_FOUND";
+    readonly TransmissionFailed: "TRANSMISSION_FAILED";
+};
+export default ErrorCodeObj;

package/cjs/ErrorCodeObj.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Not intended to be used internally. Can be useful externally
+// in projects not using TypeScript. It has the `Obj` suffix to disambiguate
+// it from the ErrorCode string union.
+const ErrorCodeObj = {
+    ConnectionDestroyed: 'CONNECTION_DESTROYED',
+    ConnectionTimeout: 'CONNECTION_TIMEOUT',
+    InvalidArgument: 'INVALID_ARGUMENT',
+    MethodCallTimeout: 'METHOD_CALL_TIMEOUT',
+    MethodNotFound: 'METHOD_NOT_FOUND',
+    TransmissionFailed: 'TRANSMISSION_FAILED',
+};
+exports.default = ErrorCodeObj;

package/cjs/PenpalError.d.ts

@@ -1,4 +1,4 @@
-import { ErrorCode } from './enums';
+import { ErrorCode } from './types';
 declare class PenpalError extends Error {
     code: ErrorCode;
     constructor(code: ErrorCode, message: string);

package/cjs/Reply.d.ts

@@ -1,8 +1,7 @@
-declare const brand: unique symbol;
 declare class Reply<T = unknown> {
+    #private;
     readonly value: T;
     readonly transferables?: Transferable[];
-    private [brand];
     constructor(value: T, options?: {
         transferables?: Transferable[];
     });

package/cjs/Reply.js

@@ -6,7 +6,8 @@ class Reply {
     transferables;
     // Allows TypeScript to distinguish between an actual instance of this
     // class versus an object that looks structurally similar.
-    [brand] = brand;
+    // eslint-disable-next-line no-unused-private-class-members
+    #brand = brand;
     constructor(value, options) {
         this.value = value;
         this.transferables = options?.transferables;

package/cjs/backwardCompatibility.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.downgradeMessage = exports.upgradeMessage = exports.isDeprecatedMessage = exports.DEPRECATED_PENPAL_PARTICIPANT_ID = void 0;
 const namespace_1 = require("./namespace");
-const enums_1 = require("./enums");
 const guards_1 = require("./guards");
 const PenpalBugError_1 = require("./PenpalBugError");
 exports.DEPRECATED_PENPAL_PARTICIPANT_ID = 'deprecated-penpal';
@@ -34,7 +33,7 @@ const upgradeMessage = (message) => {
         return {
             namespace: namespace_1.default,
             channel: undefined,
-            type: enums_1.MessageType.Syn,
+            type: 'SYN',
             participantId: exports.DEPRECATED_PENPAL_PARTICIPANT_ID,
         };
     }
@@ -42,14 +41,14 @@ const upgradeMessage = (message) => {
         return {
             namespace: namespace_1.default,
             channel: undefined,
-            type: enums_1.MessageType.Ack2,
+            type: 'ACK2',
         };
     }
     if (message.penpal === DeprecatedMessageType.Call) {
         return {
             namespace: namespace_1.default,
             channel: undefined,
-            type: enums_1.MessageType.Call,
+            type: 'CALL',
             // Actually converting the ID to a string would break communication.
             id: message.id,
             methodPath: upgradeMethodPath(message.methodName),
@@ -61,7 +60,7 @@ const upgradeMessage = (message) => {
             return {
                 namespace: namespace_1.default,
                 channel: undefined,
-                type: enums_1.MessageType.Reply,
+                type: 'REPLY',
                 // Actually converting the ID to a string would break communication.
                 callId: message.id,
                 value: message.returnValue,
@@ -71,7 +70,7 @@ const upgradeMessage = (message) => {
             return {
                 namespace: namespace_1.default,
                 channel: undefined,
-                type: enums_1.MessageType.Reply,
+                type: 'REPLY',
                 // Actually converting the ID to a string would break communication.
                 callId: message.id,
                 isError: true,

package/cjs/connect.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const PenpalError_1 = require("./PenpalError");
-const enums_1 = require("./enums");
 const shakeHands_1 = require("./shakeHands");
 const guards_1 = require("./guards");
 const once_1 = require("./once");
@@ -12,10 +11,10 @@ const usedMessengers = new WeakSet();
  */
 const connect = ({ messenger, methods = {}, timeout, channel, log, }) => {
     if (!messenger) {
-        throw new PenpalError_1.default(enums_1.ErrorCode.InvalidArgument, 'messenger must be defined');
+        throw new PenpalError_1.default('INVALID_ARGUMENT', 'messenger must be defined');
     }
     if (usedMessengers.has(messenger)) {
-        throw new PenpalError_1.default(enums_1.ErrorCode.InvalidArgument, 'A messenger can only be used for a single connection');
+        throw new PenpalError_1.default('INVALID_ARGUMENT', 'A messenger can only be used for a single connection');
     }
     usedMessengers.add(messenger);
     const connectionDestroyedHandlers = [messenger.destroy];
@@ -24,7 +23,7 @@ const connect = ({ messenger, methods = {}, timeout, channel, log, }) => {
             const destroyMessage = {
                 namespace: namespace_1.default,
                 channel,
-                type: enums_1.MessageType.Destroy,
+                type: 'DESTROY',
             };
             try {
                 messenger.sendMessage(destroyMessage);

package/cjs/connectCallHandler.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const errorSerialization_1 = require("./errorSerialization");
-const enums_1 = require("./enums");
 const Reply_1 = require("./Reply");
 const PenpalError_1 = require("./PenpalError");
 const methodSerialization_1 = require("./methodSerialization");
@@ -10,7 +9,7 @@ const namespace_1 = require("./namespace");
 const createErrorReplyMessage = (channel, callId, error) => ({
     namespace: namespace_1.default,
     channel,
-    type: enums_1.MessageType.Reply,
+    type: 'REPLY',
     callId,
     isError: true,
     ...(error instanceof Error
@@ -42,7 +41,7 @@ const connectCallHandler = (messenger, methods, channel, log) => {
         try {
             const method = (0, methodSerialization_1.getMethodAtMethodPath)(methodPath, methods);
             if (!method) {
-                throw new PenpalError_1.default(enums_1.ErrorCode.MethodNotFound, `Method \`${(0, methodSerialization_1.formatMethodPath)(methodPath)}\` is not found.`);
+                throw new PenpalError_1.default('METHOD_NOT_FOUND', `Method \`${(0, methodSerialization_1.formatMethodPath)(methodPath)}\` is not found.`);
             }
             let value = await method(...args);
             if (value instanceof Reply_1.default) {
@@ -52,7 +51,7 @@ const connectCallHandler = (messenger, methods, channel, log) => {
             replyMessage = {
                 namespace: namespace_1.default,
                 channel,
-                type: enums_1.MessageType.Reply,
+                type: 'REPLY',
                 callId,
                 value,
             };
@@ -74,7 +73,7 @@ const connectCallHandler = (messenger, methods, channel, log) => {
             // If a consumer attempts to send an object that's not
             // cloneable (e.g., window), we want to ensure the receiver's promise
             // gets rejected.
-            if (error.name === enums_1.NativeErrorName.DataCloneError) {
+            if (error.name === 'DataCloneError') {
                 replyMessage = createErrorReplyMessage(channel, callId, error);
                 log?.(`Sending ${(0, methodSerialization_1.formatMethodPath)(methodPath)}() reply`, replyMessage);
                 messenger.sendMessage(replyMessage);

package/cjs/connectRemoteProxy.js

@@ -3,18 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const generateId_1 = require("./generateId");
 const errorSerialization_1 = require("./errorSerialization");
 const methodSerialization_1 = require("./methodSerialization");
-const enums_1 = require("./enums");
 const CallOptions_1 = require("./CallOptions");
 const PenpalError_1 = require("./PenpalError");
 const guards_1 = require("./guards");
 const namespace_1 = require("./namespace");
+const methodsToTreatAsNative = new Set(['apply', 'call', 'bind']);
 const createRemoteProxy = (callback, log, path = []) => {
-    return new Proxy(path
+    return new Proxy(path.length
         ? () => {
             // Intentionally empty
         }
         : Object.create(null), {
-        get(_target, prop) {
+        get(target, prop) {
             // If a promise is resolved with this proxy object, the JavaScript
             // runtime will look for a `then` property on this object to determine
             // if it should be treated as a promise (to support promise chaining).
@@ -24,24 +24,33 @@ const createRemoteProxy = (callback, log, path = []) => {
             if (prop === 'then') {
                 return;
             }
+            // Because we're using a proxy and because Penpal supports developers
+            // exposing nested methods, we have a predicament. If a developer
+            // calls, for example, remote.auth.apply(), are they
+            // attempting to call a nested apply() method that a developer has
+            // explicitly exposed from the remote? Could they instead be attempting
+            // to call Function.prototype.apply() on the remote.auth() method?
+            // Without the remote telling the local Penpal which methods the
+            // developer has exposed, it has no way of knowing (and the main reason
+            // we use a proxy is so that Penpal doesn't have to communicate which
+            // methods are exposed). So, we treat certain methods as native methods
+            // and return the native method rather than a proxy. The downside of
+            // this is that if a developer has explicitly exposed a nested method
+            // with the same name as one of these native method names, the developer
+            // will be unable to call the exposed remote method because they will
+            // be calling the method on the Function prototype instead.
+            if (path.length && methodsToTreatAsNative.has(prop)) {
+                return Reflect.get(target, prop);
+            }
             return createRemoteProxy(callback, log, [...path, prop]);
         },
         apply(target, _thisArg, args) {
-            if (log) {
-                const lastPathSegment = path.at(-1);
-                const builtInFunction = target[lastPathSegment];
-                if ((0, guards_1.isFunction)(builtInFunction)) {
-                    log(`You may be attempting to call the native ` +
-                        `\`${lastPathSegment}\` method which is not supported. Call ` +
-                        `will be sent to remote.`);
-                }
-            }
             return callback(path, args);
         },
     });
 };
 const getDestroyedConnectionMethodCallError = (methodPath) => {
-    return new PenpalError_1.default(enums_1.ErrorCode.ConnectionDestroyed, `Method call ${(0, methodSerialization_1.formatMethodPath)(methodPath)}() failed due to destroyed connection`);
+    return new PenpalError_1.default('CONNECTION_DESTROYED', `Method call ${(0, methodSerialization_1.formatMethodPath)(methodPath)}() failed due to destroyed connection`);
 };
 /**
  * Creates a proxy. When methods are called on the proxy, a "call" message will
@@ -89,10 +98,10 @@ const connectRemoteProxy = (messenger, channel, log) => {
             // running tests if we don't disambiguate the browser setTimeout
             // from node's setTimeout. There may be a better way to configure
             // Karma + Rollup + Typescript to avoid node type leakage.
-            const timeoutId = timeout
+            const timeoutId = timeout !== undefined
                 ? window.setTimeout(() => {
                     replyHandlers.delete(callId);
-                    reject(new PenpalError_1.default(enums_1.ErrorCode.MethodCallTimeout, `Method call ${(0, methodSerialization_1.formatMethodPath)(methodPath)}() timed out after ${timeout}ms`));
+                    reject(new PenpalError_1.default('METHOD_CALL_TIMEOUT', `Method call ${(0, methodSerialization_1.formatMethodPath)(methodPath)}() timed out after ${timeout}ms`));
                 }, timeout)
                 : undefined;
             replyHandlers.set(callId, { methodPath, resolve, reject, timeoutId });
@@ -100,7 +109,7 @@ const connectRemoteProxy = (messenger, channel, log) => {
                 const callMessage = {
                     namespace: namespace_1.default,
                     channel,
-                    type: enums_1.MessageType.Call,
+                    type: 'CALL',
                     id: callId,
                     methodPath,
                     args: argsWithoutOptions,
@@ -109,7 +118,7 @@ const connectRemoteProxy = (messenger, channel, log) => {
                 messenger.sendMessage(callMessage, transferables);
             }
             catch (error) {
-                reject(new PenpalError_1.default(enums_1.ErrorCode.TransmissionFailed, error.message));
+                reject(new PenpalError_1.default('TRANSMISSION_FAILED', error.message));
             }
         });
     }, log);

package/cjs/guards.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDestroyMessage = exports.isReplyMessage = exports.isCallMessage = exports.isAck2Message = exports.isAck1Message = exports.isSynMessage = exports.isMessage = exports.isFunction = exports.isObject = void 0;
 const namespace_1 = require("./namespace");
-const enums_1 = require("./enums");
 const isObject = (value) => {
     return typeof value === 'object' && value !== null;
 };
@@ -16,26 +15,26 @@ const isMessage = (data) => {
 };
 exports.isMessage = isMessage;
 const isSynMessage = (message) => {
-    return message.type === enums_1.MessageType.Syn;
+    return message.type === 'SYN';
 };
 exports.isSynMessage = isSynMessage;
 const isAck1Message = (message) => {
-    return message.type === enums_1.MessageType.Ack1;
+    return message.type === 'ACK1';
 };
 exports.isAck1Message = isAck1Message;
 const isAck2Message = (message) => {
-    return message.type === enums_1.MessageType.Ack2;
+    return message.type === 'ACK2';
 };
 exports.isAck2Message = isAck2Message;
 const isCallMessage = (message) => {
-    return message.type === enums_1.MessageType.Call;
+    return message.type === 'CALL';
 };
 exports.isCallMessage = isCallMessage;
 const isReplyMessage = (message) => {
-    return message.type === enums_1.MessageType.Reply;
+    return message.type === 'REPLY';
 };
 exports.isReplyMessage = isReplyMessage;
 const isDestroyMessage = (message) => {
-    return message.type === enums_1.MessageType.Destroy;
+    return message.type === 'DESTROY';
 };
 exports.isDestroyMessage = isDestroyMessage;

package/cjs/index.d.ts

@@ -5,6 +5,6 @@ export { default as PortMessenger } from './messengers/PortMessenger';
 export { default as CallOptions } from './CallOptions';
 export { default as Reply } from './Reply';
 export { default as PenpalError } from './PenpalError';
+export { default as ErrorCode } from './ErrorCodeObj';
 export { default as debug } from './debug';
-export { ErrorCode } from './enums';
 export { Connection, RemoteProxy, Methods } from './types';

package/cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorCode = exports.debug = exports.PenpalError = exports.Reply = exports.CallOptions = exports.PortMessenger = exports.WorkerMessenger = exports.WindowMessenger = exports.connect = void 0;
+exports.debug = exports.ErrorCode = exports.PenpalError = exports.Reply = exports.CallOptions = exports.PortMessenger = exports.WorkerMessenger = exports.WindowMessenger = exports.connect = void 0;
 var connect_1 = require("./connect");
 Object.defineProperty(exports, "connect", { enumerable: true, get: function () { return connect_1.default; } });
 var WindowMessenger_1 = require("./messengers/WindowMessenger");
@@ -15,7 +15,7 @@ var Reply_1 = require("./Reply");
 Object.defineProperty(exports, "Reply", { enumerable: true, get: function () { return Reply_1.default; } });
 var PenpalError_1 = require("./PenpalError");
 Object.defineProperty(exports, "PenpalError", { enumerable: true, get: function () { return PenpalError_1.default; } });
+var ErrorCodeObj_1 = require("./ErrorCodeObj");
+Object.defineProperty(exports, "ErrorCode", { enumerable: true, get: function () { return ErrorCodeObj_1.default; } });
 var debug_1 = require("./debug");
 Object.defineProperty(exports, "debug", { enumerable: true, get: function () { return debug_1.default; } });
-var enums_1 = require("./enums");
-Object.defineProperty(exports, "ErrorCode", { enumerable: true, get: function () { return enums_1.ErrorCode; } });

package/cjs/indexForBundle.d.ts

@@ -4,7 +4,6 @@ import PortMessenger from './messengers/PortMessenger';
 import CallOptions from './CallOptions';
 import Reply from './Reply';
 import PenpalError from './PenpalError';
-import { ErrorCode } from './enums';
 declare const _default: {
     connect: <TMethods extends import("./types").Methods>({ messenger, methods, timeout, channel, log, }: {
         messenger: import("./messengers/Messenger").default;
@@ -20,6 +19,13 @@ declare const _default: {
     Reply: typeof Reply;
     PenpalError: typeof PenpalError;
     debug: (prefix?: string) => import("./types").Log;
-    ErrorCode: typeof ErrorCode;
+    ErrorCode: {
+        readonly ConnectionDestroyed: "CONNECTION_DESTROYED";
+        readonly ConnectionTimeout: "CONNECTION_TIMEOUT";
+        readonly InvalidArgument: "INVALID_ARGUMENT";
+        readonly MethodCallTimeout: "METHOD_CALL_TIMEOUT";
+        readonly MethodNotFound: "METHOD_NOT_FOUND";
+        readonly TransmissionFailed: "TRANSMISSION_FAILED";
+    };
 };
 export default _default;

package/cjs/indexForBundle.js

@@ -7,8 +7,8 @@ const PortMessenger_1 = require("./messengers/PortMessenger");
 const CallOptions_1 = require("./CallOptions");
 const Reply_1 = require("./Reply");
 const PenpalError_1 = require("./PenpalError");
+const ErrorCodeObj_1 = require("./ErrorCodeObj");
 const debug_1 = require("./debug");
-const enums_1 = require("./enums");
 exports.default = {
     connect: connect_1.default,
     WindowMessenger: WindowMessenger_1.default,
@@ -18,5 +18,5 @@ exports.default = {
     Reply: Reply_1.default,
     PenpalError: PenpalError_1.default,
     debug: debug_1.default,
-    ErrorCode: enums_1.ErrorCode,
+    ErrorCode: ErrorCodeObj_1.default,
 };

package/cjs/messengers/PortMessenger.d.ts

@@ -10,12 +10,9 @@ type Options = {
  * Handles the details of communicating on a MessagePort.
  */
 declare class PortMessenger implements Messenger {
-    private _port;
-    private _validateReceivedMessage?;
-    private _messageCallbacks;
+    #private;
     constructor({ port }: Options);
     initialize: ({ validateReceivedMessage }: InitializeOptions) => void;
-    private _handleMessage;
     sendMessage: (message: Message, transferables?: Transferable[]) => void;
     addMessageHandler: (callback: MessageHandler) => void;
     removeMessageHandler: (callback: MessageHandler) => void;

package/cjs/messengers/PortMessenger.js

@@ -1,48 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const PenpalError_1 = require("../PenpalError");
-const enums_1 = require("../enums");
 /**
  * Handles the details of communicating on a MessagePort.
  */
 class PortMessenger {
-    _port;
-    _validateReceivedMessage;
-    _messageCallbacks = new Set();
+    #port;
+    #validateReceivedMessage;
+    #messageCallbacks = new Set();
     constructor({ port }) {
         if (!port) {
-            throw new PenpalError_1.default(enums_1.ErrorCode.InvalidArgument, 'port must be defined');
+            throw new PenpalError_1.default('INVALID_ARGUMENT', 'port must be defined');
         }
-        this._port = port;
+        this.#port = port;
     }
     initialize = ({ validateReceivedMessage }) => {
-        this._validateReceivedMessage = validateReceivedMessage;
-        this._port.addEventListener('message', this._handleMessage);
-        this._port.start();
-    };
-    _handleMessage = ({ data }) => {
-        if (!this._validateReceivedMessage?.(data)) {
-            return;
-        }
-        for (const callback of this._messageCallbacks) {
-            callback(data);
-        }
+        this.#validateReceivedMessage = validateReceivedMessage;
+        this.#port.addEventListener('message', this.#handleMessage);
+        this.#port.start();
     };
     sendMessage = (message, transferables) => {
-        this._port?.postMessage(message, {
+        this.#port?.postMessage(message, {
             transfer: transferables,
         });
     };
     addMessageHandler = (callback) => {
-        this._messageCallbacks.add(callback);
+        this.#messageCallbacks.add(callback);
     };
     removeMessageHandler = (callback) => {
-        this._messageCallbacks.delete(callback);
+        this.#messageCallbacks.delete(callback);
     };
     destroy = () => {
-        this._port.removeEventListener('message', this._handleMessage);
-        this._port.close();
-        this._messageCallbacks.clear();
+        this.#port.removeEventListener('message', this.#handleMessage);
+        this.#port.close();
+        this.#messageCallbacks.clear();
+    };
+    #handleMessage = ({ data }) => {
+        if (!this.#validateReceivedMessage?.(data)) {
+            return;
+        }
+        for (const callback of this.#messageCallbacks) {
+            callback(data);
+        }
     };
 }
 exports.default = PortMessenger;

package/cjs/messengers/WindowMessenger.d.ts

@@ -18,21 +18,9 @@ type Options = {
  * Handles the details of communicating with a child window.
  */
 declare class WindowMessenger implements Messenger {
-    private _remoteWindow;
-    private _allowedOrigins;
-    private _log?;
-    private _validateReceivedMessage?;
-    private _concreteRemoteOrigin?;
-    private _messageCallbacks;
-    private _port?;
-    private _isChildUsingDeprecatedProtocol;
+    #private;
     constructor({ remoteWindow, allowedOrigins }: Options);
     initialize: ({ log, validateReceivedMessage }: InitializeOptions) => void;
-    private _isAllowedOrigin;
-    private _getOriginForSendingMessage;
-    private _destroyPort;
-    private _handleMessageFromRemoteWindow;
-    private _handleMessageFromPort;
     sendMessage: (message: Message, transferables?: Transferable[]) => void;
     addMessageHandler: (callback: MessageHandler) => void;
     removeMessageHandler: (callback: MessageHandler) => void;