@dynamic-labs/message-transport 2.0.0-alpha.26

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Dynamic Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# Message transport
+
+This package implements the communication protocol used to send and receive messages to/from text based channels, such as a webview.

package/_virtual/_tslib.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).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;
+};
+
+exports.__awaiter = __awaiter;

package/_virtual/_tslib.js

@@ -0,0 +1,31 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).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;
+};
+
+export { __awaiter };

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@dynamic-labs/message-transport",
+  "version": "2.0.0-alpha.26",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dynamic-labs/DynamicAuth.git",
+    "directory": "packages/message-transport"
+  },
+  "description": "Defines the interface to communicate with dynamic's webview",
+  "bugs": {
+    "url": "https://github.com/dynamic-labs/DynamicAuth/issues"
+  },
+  "homepage": "https://github.com/dynamic-labs/DynamicAuth/main/packages/message-transport#readme",
+  "author": "Dynamic Labs, Inc.",
+  "license": "MIT",
+  "main": "./src/index.cjs",
+  "module": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "require": "./src/index.cjs"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/src/index.cjs

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var messageTransport = require('./messageTransport/messageTransport.cjs');
+var applyDefaultMessageOrigin = require('./messageTransport/decorators/applyDefaultMessageOrigin/applyDefaultMessageOrigin.cjs');
+var makeWaitForInitEvent = require('./messageTransport/decorators/makeWaitForInitEvent/makeWaitForInitEvent.cjs');
+var makeWaitForUnblock = require('./messageTransport/decorators/makeWaitForUnblock/makeWaitForUnblock.cjs');
+var requestChannel = require('./requestChannel/requestChannel.cjs');
+var parseMessageTransportData = require('./utils/parseMessageTransportData/parseMessageTransportData.cjs');
+var SdkModuleMessages = require('./messageTypes/SdkModuleMessages.cjs');
+
+
+
+exports.createMessageTransport = messageTransport.createMessageTransport;
+exports.applyDefaultMessageOrigin = applyDefaultMessageOrigin.applyDefaultMessageOrigin;
+exports.makeWaitForInitEvent = makeWaitForInitEvent.makeWaitForInitEvent;
+exports.makeWaitForUnblock = makeWaitForUnblock.makeWaitForUnblock;
+exports.createRequestChannel = requestChannel.createRequestChannel;
+exports.parseMessageTransportData = parseMessageTransportData.parseMessageTransportData;
+exports.sdkHasLoadedEventName = SdkModuleMessages.sdkHasLoadedEventName;

package/src/index.d.ts

@@ -0,0 +1,4 @@
+export { applyDefaultMessageOrigin, createMessageTransport, makeWaitForInitEvent, makeWaitForUnblock, type BypassBlockCallback, type MessageTransport, type MessageTransportCallback, type MessageTransportData, type MessageTransportDataOptionalOrigin, type MessageTransportWithDefaultOrigin, } from './messageTransport';
+export { type RequestChannel, createRequestChannel } from './requestChannel';
+export { parseMessageTransportData } from './utils/parseMessageTransportData';
+export { type ClientManifest, type SdkModuleMessages, sdkHasLoadedEventName, } from './messageTypes';

package/src/index.js

@@ -0,0 +1,7 @@
+export { createMessageTransport } from './messageTransport/messageTransport.js';
+export { applyDefaultMessageOrigin } from './messageTransport/decorators/applyDefaultMessageOrigin/applyDefaultMessageOrigin.js';
+export { makeWaitForInitEvent } from './messageTransport/decorators/makeWaitForInitEvent/makeWaitForInitEvent.js';
+export { makeWaitForUnblock } from './messageTransport/decorators/makeWaitForUnblock/makeWaitForUnblock.js';
+export { createRequestChannel } from './requestChannel/requestChannel.js';
+export { parseMessageTransportData } from './utils/parseMessageTransportData/parseMessageTransportData.js';
+export { sdkHasLoadedEventName } from './messageTypes/SdkModuleMessages.js';

package/src/messageTransport/decorators/applyDefaultMessageOrigin/applyDefaultMessageOrigin.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/** Allows setting a default origin, making the origin property optional */
+const applyDefaultMessageOrigin = ({ defaultOrigin, messageTransport, }) => (Object.assign(Object.assign({}, messageTransport), { defaultOrigin, emit: (message) => {
+        var _a;
+        messageTransport.emit(Object.assign(Object.assign({}, message), { origin: (_a = message.origin) !== null && _a !== void 0 ? _a : defaultOrigin }));
+    } }));
+
+exports.applyDefaultMessageOrigin = applyDefaultMessageOrigin;

package/src/messageTransport/decorators/applyDefaultMessageOrigin/applyDefaultMessageOrigin.d.ts

@@ -0,0 +1,15 @@
+import { MessageTransport, MessageTransportData } from '../../messageTransport';
+export type MessageTransportDataOptionalOrigin = Omit<MessageTransportData, 'origin'> & {
+    origin?: MessageTransportData['origin'];
+};
+export type MessageTransportWithDefaultOrigin = ReturnType<typeof applyDefaultMessageOrigin>;
+type ApplyDefaultMessageOriginProps<T extends MessageTransport> = {
+    defaultOrigin: MessageTransportData['origin'];
+    messageTransport: T;
+};
+/** Allows setting a default origin, making the origin property optional */
+export declare const applyDefaultMessageOrigin: <T extends MessageTransport>({ defaultOrigin, messageTransport, }: ApplyDefaultMessageOriginProps<T>) => T & {
+    defaultOrigin: "webview" | "host";
+    emit: (message: MessageTransportDataOptionalOrigin) => void;
+};
+export {};

package/src/messageTransport/decorators/applyDefaultMessageOrigin/applyDefaultMessageOrigin.js

@@ -0,0 +1,7 @@
+/** Allows setting a default origin, making the origin property optional */
+const applyDefaultMessageOrigin = ({ defaultOrigin, messageTransport, }) => (Object.assign(Object.assign({}, messageTransport), { defaultOrigin, emit: (message) => {
+        var _a;
+        messageTransport.emit(Object.assign(Object.assign({}, message), { origin: (_a = message.origin) !== null && _a !== void 0 ? _a : defaultOrigin }));
+    } }));
+
+export { applyDefaultMessageOrigin };

package/src/messageTransport/decorators/applyDefaultMessageOrigin/index.d.ts

@@ -0,0 +1 @@
+export * from './applyDefaultMessageOrigin';

package/src/messageTransport/decorators/index.d.ts

@@ -0,0 +1,3 @@
+export * from './applyDefaultMessageOrigin';
+export * from './makeWaitForInitEvent';
+export * from './makeWaitForUnblock';

package/src/messageTransport/decorators/makeWaitForInitEvent/index.d.ts

@@ -0,0 +1 @@
+export * from './makeWaitForInitEvent';

package/src/messageTransport/decorators/makeWaitForInitEvent/makeWaitForInitEvent.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var makeWaitForUnblock = require('../makeWaitForUnblock/makeWaitForUnblock.cjs');
+
+/**
+ * Decorator that adds the following features to a MessageTransport:
+ * 1. Any emit calls will not emit the message yet. These messages will be stored.
+ * 2. When the provided messageTransport receives a message of type initializeMessageType:
+ *    1. All stored messages are emitted.
+ *    2. Any future emit calls will no longer store the message, and instead
+ *      will emit them right away, as normal.
+ */
+const makeWaitForInitEvent = ({ bypassBlockIf, initializeMessageType, messageTransport, }) => {
+    // Reuse unblock decorator
+    const blockedTransport = makeWaitForUnblock.makeWaitForUnblock({
+        bypassBlockIf,
+        messageTransport,
+    });
+    const handleInitialization = ({ type }) => {
+        // Check if we are to initialize
+        if (type !== initializeMessageType)
+            return;
+        blockedTransport.unblock();
+        // Cleanup this listener
+        messageTransport.off(handleInitialization);
+    };
+    // Listen for initialization
+    messageTransport.on(handleInitialization);
+    return blockedTransport;
+};
+
+exports.makeWaitForInitEvent = makeWaitForInitEvent;

package/src/messageTransport/decorators/makeWaitForInitEvent/makeWaitForInitEvent.d.ts

@@ -0,0 +1,25 @@
+import { MessageTransport, MessageTransportData } from '../../messageTransport';
+import { BypassBlockCallback } from '../makeWaitForUnblock';
+type MakeWaitForInitEventProps = {
+    /** MessageTransport to add this decorator to */
+    messageTransport: MessageTransport;
+    /** Which message type should trigger the initialization */
+    initializeMessageType: string;
+    /** If true is returned, the message will not be blocked */
+    bypassBlockIf?: BypassBlockCallback;
+};
+/**
+ * Decorator that adds the following features to a MessageTransport:
+ * 1. Any emit calls will not emit the message yet. These messages will be stored.
+ * 2. When the provided messageTransport receives a message of type initializeMessageType:
+ *    1. All stored messages are emitted.
+ *    2. Any future emit calls will no longer store the message, and instead
+ *      will emit them right away, as normal.
+ */
+export declare const makeWaitForInitEvent: ({ bypassBlockIf, initializeMessageType, messageTransport, }: MakeWaitForInitEventProps) => {
+    unblock: () => void;
+    emit: (message: MessageTransportData) => void;
+    off: (callback: import("../../messageTransport").MessageTransportCallback) => void;
+    on: (callback: import("../../messageTransport").MessageTransportCallback) => void;
+};
+export {};

package/src/messageTransport/decorators/makeWaitForInitEvent/makeWaitForInitEvent.js

@@ -0,0 +1,30 @@
+import { makeWaitForUnblock } from '../makeWaitForUnblock/makeWaitForUnblock.js';
+
+/**
+ * Decorator that adds the following features to a MessageTransport:
+ * 1. Any emit calls will not emit the message yet. These messages will be stored.
+ * 2. When the provided messageTransport receives a message of type initializeMessageType:
+ *    1. All stored messages are emitted.
+ *    2. Any future emit calls will no longer store the message, and instead
+ *      will emit them right away, as normal.
+ */
+const makeWaitForInitEvent = ({ bypassBlockIf, initializeMessageType, messageTransport, }) => {
+    // Reuse unblock decorator
+    const blockedTransport = makeWaitForUnblock({
+        bypassBlockIf,
+        messageTransport,
+    });
+    const handleInitialization = ({ type }) => {
+        // Check if we are to initialize
+        if (type !== initializeMessageType)
+            return;
+        blockedTransport.unblock();
+        // Cleanup this listener
+        messageTransport.off(handleInitialization);
+    };
+    // Listen for initialization
+    messageTransport.on(handleInitialization);
+    return blockedTransport;
+};
+
+export { makeWaitForInitEvent };

package/src/messageTransport/decorators/makeWaitForUnblock/index.d.ts

@@ -0,0 +1 @@
+export * from './makeWaitForUnblock';

package/src/messageTransport/decorators/makeWaitForUnblock/makeWaitForUnblock.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Decorator that adds the following features to a MessageTransport:
+ * 1. Any emit calls will not emit the message yet. These messages will be stored.
+ * 2. When the unblock method is called:
+ *    1. All stored messages are emitted.
+ *    2. Any future emit calls will no longer store the message, and instead
+ *      will emit them right away, as normal.
+ */
+const makeWaitForUnblock = ({ messageTransport, bypassBlockIf = () => false, }) => {
+    /** Whether to block any new messages */
+    let blocked = true;
+    /** Messages pending to be sent once unblocked */
+    let pendingMessages = [];
+    /**
+     * Ids of incoming message sessions.
+     * We don't want to block responses to these messages.
+     */
+    const bypassedMessageSessionIds = new Set();
+    const extendedTransport = {
+        emit: (message) => {
+            if (bypassBlockIf(message) && blocked) {
+                bypassedMessageSessionIds.add(message.messageSessionId);
+            }
+            // Even if blocking, we still want to let through ids of messages that
+            // can bypass the block (this includes any responses, since they share the same id)
+            if (blocked && !bypassedMessageSessionIds.has(message.messageSessionId)) {
+                pendingMessages.push(message);
+                return;
+            }
+            messageTransport.emit(message);
+        },
+        off: (callback) => messageTransport.off(callback),
+        on: (callback) => messageTransport.on(callback),
+    };
+    const unblock = () => {
+        if (!blocked)
+            return;
+        blocked = false;
+        // Emit all stored messages
+        for (const message of pendingMessages)
+            messageTransport.emit(message);
+        pendingMessages = [];
+        bypassedMessageSessionIds.clear();
+    };
+    return Object.assign(Object.assign({}, extendedTransport), { unblock });
+};
+
+exports.makeWaitForUnblock = makeWaitForUnblock;

package/src/messageTransport/decorators/makeWaitForUnblock/makeWaitForUnblock.d.ts

@@ -0,0 +1,23 @@
+import { MessageTransport, MessageTransportData } from '../../messageTransport';
+export type BypassBlockCallback = (message: MessageTransportData) => boolean;
+type MakeWaitForUnblockProps = {
+    /** MessageTransport to add this decorator to */
+    messageTransport: MessageTransport;
+    /** If true is return the message will not be blocked */
+    bypassBlockIf?: BypassBlockCallback;
+};
+/**
+ * Decorator that adds the following features to a MessageTransport:
+ * 1. Any emit calls will not emit the message yet. These messages will be stored.
+ * 2. When the unblock method is called:
+ *    1. All stored messages are emitted.
+ *    2. Any future emit calls will no longer store the message, and instead
+ *      will emit them right away, as normal.
+ */
+export declare const makeWaitForUnblock: ({ messageTransport, bypassBlockIf, }: MakeWaitForUnblockProps) => {
+    unblock: () => void;
+    emit: (message: MessageTransportData) => void;
+    off: (callback: import("../../messageTransport").MessageTransportCallback) => void;
+    on: (callback: import("../../messageTransport").MessageTransportCallback) => void;
+};
+export {};

package/src/messageTransport/decorators/makeWaitForUnblock/makeWaitForUnblock.js

@@ -0,0 +1,48 @@
+/**
+ * Decorator that adds the following features to a MessageTransport:
+ * 1. Any emit calls will not emit the message yet. These messages will be stored.
+ * 2. When the unblock method is called:
+ *    1. All stored messages are emitted.
+ *    2. Any future emit calls will no longer store the message, and instead
+ *      will emit them right away, as normal.
+ */
+const makeWaitForUnblock = ({ messageTransport, bypassBlockIf = () => false, }) => {
+    /** Whether to block any new messages */
+    let blocked = true;
+    /** Messages pending to be sent once unblocked */
+    let pendingMessages = [];
+    /**
+     * Ids of incoming message sessions.
+     * We don't want to block responses to these messages.
+     */
+    const bypassedMessageSessionIds = new Set();
+    const extendedTransport = {
+        emit: (message) => {
+            if (bypassBlockIf(message) && blocked) {
+                bypassedMessageSessionIds.add(message.messageSessionId);
+            }
+            // Even if blocking, we still want to let through ids of messages that
+            // can bypass the block (this includes any responses, since they share the same id)
+            if (blocked && !bypassedMessageSessionIds.has(message.messageSessionId)) {
+                pendingMessages.push(message);
+                return;
+            }
+            messageTransport.emit(message);
+        },
+        off: (callback) => messageTransport.off(callback),
+        on: (callback) => messageTransport.on(callback),
+    };
+    const unblock = () => {
+        if (!blocked)
+            return;
+        blocked = false;
+        // Emit all stored messages
+        for (const message of pendingMessages)
+            messageTransport.emit(message);
+        pendingMessages = [];
+        bypassedMessageSessionIds.clear();
+    };
+    return Object.assign(Object.assign({}, extendedTransport), { unblock });
+};
+
+export { makeWaitForUnblock };

package/src/messageTransport/index.d.ts

@@ -0,0 +1,2 @@
+export * from './messageTransport';
+export * from './decorators';

package/src/messageTransport/messageTransport.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/** Creates a simple message transport for general use */
+const createMessageTransport = () => {
+    const listeners = new Set();
+    return {
+        emit: (message) => listeners.forEach((callback) => callback(message)),
+        off: (callback) => listeners.delete(callback),
+        on: (callback) => listeners.add(callback),
+    };
+};
+
+exports.createMessageTransport = createMessageTransport;

package/src/messageTransport/messageTransport.d.ts

@@ -0,0 +1,44 @@
+/** Defines the structure of messages that can be sent to and from webviews */
+export type MessageTransportData = {
+    /**
+     * Defines which kind of message this is.
+     *
+     * Ex: "link-wallet", "logout"
+     */
+    type: string;
+    /**
+     * Any relevant arguments attached to the message.
+     * Its contents must be interpreted according to the type of the message.
+     *
+     * Ex: for "link-wallet" type, can be ["metamask"], which should be interpreted as
+     * the target wallet connector.
+     */
+    args: unknown[];
+    /**
+     * A string that uniquely identifies this message exchange session.
+     * If the other end wants to send another message as a response to this message,
+     * then it should have the same messageSessionId.
+     *
+     * Ex: for "link-wallet" type, the other end could then eventually emit a message with type
+     * "link-wallet__resolved" and with the same messageSessionId, indicating a success.
+     */
+    messageSessionId: string;
+    /** Identifies which end emitted this message */
+    origin: 'webview' | 'host';
+};
+export type MessageTransportCallback = (data: MessageTransportData) => void;
+/**
+ * An interface for a structure that allows sending messages to and from webviews.
+ * Functions similarly to an event emitter, but there's some distinctions:
+ * 1. You cannot listen to specific types of messages. You either listen to all messages or none.
+ * Note that each message has a type which you can use to decide what to do with it.
+ * 2. Each message has a messageSessionId which allows the other end to "respond"
+ * by emitting another event with the same messageSessionId.
+ */
+export type MessageTransport = {
+    emit: (message: MessageTransportData) => void;
+    off: (callback: MessageTransportCallback) => void;
+    on: (callback: MessageTransportCallback) => void;
+};
+/** Creates a simple message transport for general use */
+export declare const createMessageTransport: () => MessageTransport;

package/src/messageTransport/messageTransport.js

@@ -0,0 +1,11 @@
+/** Creates a simple message transport for general use */
+const createMessageTransport = () => {
+    const listeners = new Set();
+    return {
+        emit: (message) => listeners.forEach((callback) => callback(message)),
+        off: (callback) => listeners.delete(callback),
+        on: (callback) => listeners.add(callback),
+    };
+};
+
+export { createMessageTransport };

package/src/messageTypes/SdkModuleMessages.cjs

@@ -0,0 +1,8 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/** Easy access to the event name that indicates the SDK has loaded */
+const sdkHasLoadedEventName = 'loaded';
+
+exports.sdkHasLoadedEventName = sdkHasLoadedEventName;

package/src/messageTypes/SdkModuleMessages.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Defines the settings required by the SDK to be properly initialized
+ * inside the webview
+ */
+export type ClientManifest = {
+    environmentId: string;
+    clientVersion: string;
+    apiBaseUrl?: string;
+    appName?: string;
+    appLogoUrl?: string;
+    cssOverrides?: string;
+};
+export type SdkModuleMessages = {
+    /** Sent from webview app to indicate the SDK is set up and ready for requests */
+    loaded: () => void;
+    /** Sent from the webview app to request the SDK settings */
+    manifest: () => Promise<ClientManifest>;
+};
+/** Easy access to the event name that indicates the SDK has loaded */
+export declare const sdkHasLoadedEventName: keyof SdkModuleMessages;

package/src/messageTypes/SdkModuleMessages.js

@@ -0,0 +1,4 @@
+/** Easy access to the event name that indicates the SDK has loaded */
+const sdkHasLoadedEventName = 'loaded';
+
+export { sdkHasLoadedEventName };

package/src/messageTypes/index.d.ts

@@ -0,0 +1 @@
+export * from './SdkModuleMessages';

package/src/requestChannel/index.d.ts

@@ -0,0 +1 @@
+export * from './requestChannel';