@openfin/core-web 0.38.1

package/LICENSE.md

@@ -0,0 +1,4 @@
+Learn more about OpenFin licensing at the links listed below or email us at support@openfin.co with questions.
+
+- [Developer agreement](https://openfin.co/developer-agreement/)
+

package/README.md

@@ -0,0 +1,45 @@
+# @openfin/core-web
+
+`@openfin/core-web` enables interopability within a web browser. It is intended to be used by both content and platform developers to create integrated experiences which leverage OpenFin's existing interopability APIs.
+
+This package relies on the type definitions found in [@openfin/core](https://www.npmjs.com/package/@openfin/core) which is a required peer dependency.
+
+## Developer Guides
+
+(Please note, these links work in your IDE and not on npm.org, we will update this soon.)
+
+-   [Content Developer Guide](docs/web-application-developer-guide.md) - For developers who need access to the `fin` api to build web applications.
+-   [Platform Developer Guide](docs/platform-developer-guide.md) - For developers building platform-like web experiences who wish to enable and host a Web Interop setup.
+
+## Supported APIs
+
+`@openfin/core-web` currently supports the following APIs:
+
+-   `fin.me.identity` - The identity of the `fin` instance provided by the Web Broker.
+-   `fin.InterApplicationBus.Channel.connect` - Currently, the only supported channel strategy is `classic`.
+-   `fin.InterApplicationBus.Channel.create`
+-   `InteropBroker`
+    -   `fin.Interop.init`
+-   `InteropClient`
+    -   `fin.Interop.connectSync`
+    -   `fin.me.interop`
+    -   `InteropClient.getFDC3()` - (FDC3 support is currently limited to context sharing on User Channels)
+-   `Layout`
+    -   `fin.Platform.Layout.init`
+    -   `fin.Platform.Layout.create`
+    -   `fin.Platform.Layout.destroy`
+    -   `fin.Platform.Layout.getCurrentLayoutManagerSync`
+
+## API Reference
+
+(Please note, these links work in your IDE and not on npmjs.com, we will update this soon.)
+
+-   [index](out/docs/README.md)
+-   [@openfin/core-web](out/docs/@openfin/core-web/README.md)
+-   [@openfin/core-web/iframe-broker](out/docs/@openfin/core-web/iframe-broker/README.md)
+-   [@openfin/core-web/shared-worker](out/docs/@openfin/core-web/shared-worker/README.md)
+
+## See Also
+
+-   [OpenFin Container Developer guide](https://developers.openfin.co/of-docs/docs/container-overview)
+-   [Fin API reference](https://developer.openfin.co/docs/javascript/stable)

package/docs/platform-developer-guide.md

@@ -0,0 +1,229 @@
+# Platform Developer Guide
+
+If you are a Platform owner who wants to include OpenFin's web capabilities in your platform, there are a few steps required. This section will guide you through the process of setting up an environment. Please note, none of these steps are necessary for content developers (See the [content developer guide](web-application-developer-guide.md)).
+
+## First Steps
+
+Ensure that `@openfin/core-web` is installed by running the following command:
+
+```bash
+npm i @openfin/core-web -S
+```
+
+### Host the `@openfin/core-web` Shared Worker
+
+An `@openfin/core-web/shared-worker` entry point is included in this package's distribution. This is a non-customizable, standalone piece of javascript that must be hosted on your server for `@openfin/core-web` to function.
+
+This file has already been bundled, which means you just need to host it on a web server on a known URL.
+
+## Build a Web Broker
+
+An HTML page, loaded as a hidden iframe by clients, must be hosted in the same origin as the `@openfin/shared-worker`. This iframe acts as a gatekeeper to the `shared-worker` and therefore must be hosted on the same domain.
+
+In order to build a Web Broker, the following requirements must be met:
+
+1. You must host the `@openfin/core-web/shared-worker` bundle on a domain (for example <https://www.example.com/mysharedworker.js>).
+2. You must host a web broker page on that same domain (for example, <https://www.example.com/web-broker>).
+3. That page must call `init` from `@openfin/core-web/iframe-broker` with the URL of the shared worker hosted in step 1.
+
+    ```typescript
+    // Runs on https://www.example.com/web-broker
+    import {init} from '@openfin/core-web/iframe-broker;
+
+    const sharedWorkerUrl = 'https://www.example.com/mysharedworker.js';
+
+    await init({sharedWorkerUrl})
+    ```
+
+Here is a basic example of hosting a Web Broker:
+
+### Example: Set up a Basic Web Broker
+
+First, host `@openfin/core-web/shared-worker` at `/openfin-shared-worker.js`
+
+File: iframe-broker.html
+
+```html
+<html>
+    <body>
+        <script src="iframe-broker.js"></script>
+    </body>
+</html>
+```
+
+File: iframe-broker.js
+
+```typescript
+import { init } from '@openfin/core-web/iframe-broker';
+
+init({
+    sharedWorkerUrl: `${location.origin}/openfin-shared-worker.js`
+});
+```
+
+## Reject Connections
+
+As an owner of an Iframe Broker, you should first rely on existing web security tools such as the frame-ancestors CSP rule to prevent content from connecting to you which you don't expect.
+
+`@openfin/core-web` exposes a `rejectConnections` utility if you wish to implement custom rejection logic. If neither `init` or `rejectConnection` is invoked, an embedding client may hang indefinitely.
+
+### Example: Reject a Cross Origin Connection using `@openfin/core-web/iframe-broker`
+
+```typescript
+import { init, rejectConnections } from '@openfin/core-web/iframe-broker';
+
+// If the origins do not match.
+if (new URL(document.referrer).origin !== location.origin) {
+    rejectConnections({
+        reason: 'Connections from this domain are not supported' // Reason allows an error to be returned to the connecting client.
+    });
+} else {
+    init({
+        sharedWorkerUrl: `${location.origin}/openfin-shared-worker.js`
+    });
+}
+```
+
+## Experimental: Enable Cross Tab Support
+
+By default, `@openfin/core-web` disables the sharing of connections across browser Tabs. However, this feature may be enabled by specifying the following flag in an IFrame Broker:
+
+### Example: Enable Cross Tab Support
+
+```typescript
+init({
+    sharedWorkerUrl: `${location.origin}/openfin-shared-worker.js`,
+    experimental: {
+        crossTab: 'same-site'
+    }
+});
+```
+
+## Create Layouts
+
+Layouts in the web are very similar to the desktop OpenFin environment. They consist of a layout configuration that describes the rows/columns/view components. The major difference is that the `layout` key is not supported. Instead, we expose the `layoutSnapshot` key to plug into the multiple-layout architecture. See the [Multi-Layout guide](https://developers.openfin.co/of-docs/docs/multi-layouts) for more information on how to set it up.
+
+Note that you can achieve a single layout by having only 1 key in your `layoutSnapshot`:
+
+```typescript
+const layoutSnapshot = {
+    layouts: {
+        layout: { ... }
+    }
+}
+```
+
+The JSON structure of the underlying layout options is interchangeable, though not identical, between Desktop and Web. Web Layout Snapshots have an optional `web` property within the view `componentState` options which stores web specific properties. This `web` property is ignored on desktop.
+
+### Example: Retrieve a layoutSnapshot from both desktop and web environments
+
+From within your OpenFin v34+ Desktop environment, retrieve the current layoutSnapshot:
+
+```typescript
+const layoutManager = fin.Platform.Layout.getCurrentLayoutManagerSync();
+// returns an object like: { layouts: { ... } } where each key in layouts.<key> is it's own separate layout configuration
+const layoutSnapshot = await layoutManager.getLayoutSnapshot();
+```
+
+Note that the `fin.Platform.Layout` API is exactly the same in web, so you can retrieve the Web Layout Snapshot using the same code.
+
+### Example: Create a layoutSnapshot with 2 layouts and initialize it via connect call
+
+In order to use layouts, specify the `platform` option to the `connect` call and pass in the `layoutSnapshot`.
+
+```typescript
+import { connect, type WebLayoutSnapshot } from '@openfin/core-web';
+
+const brokerUrl = 'http://example.com/web-broker';
+
+// Presumably retrieved from fin.Platform.Layout.getCurrentLayoutManagerSync().getLayoutSnapshot()
+// in a v34+ Desktop environment, but also can be manually constructed like this:
+const layoutSnapshot: WebLayoutSnapshot = {
+    layouts: {
+        tab1: {
+            content: [
+                {
+                    type: 'row',
+                    content: [
+                        {
+                            type: 'stack',
+                            content: [
+                                {
+                                    title: 'Example',
+                                    type: 'component',
+                                    componentName: 'view',
+                                    componentState: {
+                                        url: 'http://example.com/'
+                                    }
+                                }
+                            ]
+                        },
+                        {
+                            type: 'stack',
+                            content: [
+                                {
+                                    title: 'Example',
+                                    type: 'component',
+                                    componentName: 'view',
+                                    componentState: {
+                                        url: 'http://example.com/'
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        tab2: {
+            content: [
+                {
+                    type: 'stack',
+                    content: [
+                        {
+                            title: 'Example',
+                            type: 'component',
+                            componentName: 'view',
+                            componentState: {
+                                url: 'http://example.com/'
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    }
+};
+
+(async () => {
+    // Connect to the OpenFin Web Broker. Pass in the `platform` key with a layoutSnapshot.
+    const fin = await connect({
+        connectionInheritance: 'enabled',
+        options: { brokerUrl },
+        platform: { layoutSnapshot }
+    });
+
+    const container = document.getElementById('layout-container');
+
+    // You may now use the `fin` object. In this case, we want to initialize and create layouts.
+    await fin.Platform.Layout.init({ container });
+
+    // For multi-layout information see https://developers.openfin.co/of-docs/docs/multi-layouts
+    // In the multi-layout case we would also call `fin.Platform.Layout.create()`.
+})();
+```
+
+Note that cross-tab support is experimental, browser-dependent and respects each browser's privacy sandbox.
+
+## API Reference
+
+(Please note, these links work in your IDE and not on npmjs.com, we will update this soon.)
+
+- [@openfin/core-web](../out/docs/@openfin/core-web/README.md)
+- [@openfin/core-web/iframe-broker](../out/docs/@openfin/core-web/iframe-broker/README.md)
+- [@openfin/core-web/shared-worker](../out/docs/@openfin/core-web/shared-worker/README.md)
+
+## See Also
+
+- [OpenFin Container Developer guide](https://developers.openfin.co/of-docs/docs/container-overview)
+- [Fin API reference](https://developer.openfin.co/docs/javascript/stable)

package/docs/web-application-developer-guide.md

@@ -0,0 +1,123 @@
+# Openfin Web Application Developer Guide
+
+If you are a developer who is building contentful applications which use the OpenFin APIs, the default entry point of this package provides a `connect` function. This is designed to complement the type definitions found in [@openfin/core](https://www.npmjs.com/package/@openfin/core).
+
+Note - if you are a platform developer looking to setup an OpenFin Web Interop Broker, please check out [this guide](./platform-developer-guide.md).
+
+## First Steps
+
+To install `@openfin/core-web`, run the following command:
+
+```bash
+npm install @openfin/core-web -S
+```
+
+We recommend using `@openfin/core-web` with a modern build tool like Next.js, Webpack or Vite.
+
+It is framework agnostic, meaning it should work with any UI framework.
+
+## Connecting to a Web Broker
+
+An `@openfin/core-web` Web Broker is a piece of hosted infrastructure which you can connect to from a web site in order to interact with other content connected to the same Web Broker. A Web Broker is responsible for deciding whether you can connect to it, and connecting you to other applications via OpenFin's Interop and Channels APIs.
+
+When the Web Broker url is known, connecting to a specific `@openfin/core-web` broker will return a fin connection.
+
+### Example: Basic Connection Setup
+
+```typescript
+import { connect } from '@openfin/core-web';
+
+const brokerUrl = 'http://example.com/web-broker';
+
+(async () => {
+    // Connect to the OpenFin Web Broker.
+    const fin = await connect({ options: { brokerUrl } });
+
+    // You may now use the `fin` object. In this case, we connect to a channel.
+    const channelClient = await fin.InterapplicationBus.Channel.connect('some channel name');
+})();
+```
+
+## Setting a Timeout
+
+If desired, the timeout option (in milliseconds) can be specified to abandon the connection after a set amount of time.
+
+An example below shows setting up a 30 second timeout.
+
+### Example: Setting a Timeout
+
+```typescript
+// This connect call will throw if a connection is not established within 30 seconds.
+await connect({ options: { brokerUrl, timeout: 30000 } });
+```
+
+## Setting up an Interop Connection
+
+An Interop connection can be configured in order to automatically set up an interop client. This client may be accessed via the `fin.me.interop` namespace.
+
+A Provider ID must be specified for the `fin.me.interop` client to work if `connectionInheritance` is not supported. An example is shown below:
+
+### Example: Connecting to an Interop Broker
+
+```typescript
+// Specify an interopConfig with a specific provider ID to initialize the `fin.me.interop` client on connection.
+const fin = await connect({ options: { brokerUrl, interopConfig: { providerId: 'provider-id' } } });
+
+// fin.me.interop is an InteropClient connected to the `provider-id` InteropBroker.
+fin.me.interop.addContextHandler((context) => console.log('received context'));
+```
+
+## Specifying an Initial Context Group
+
+By default OpenFin's Interop Client api does not select a context group. The following example illustrates setting up an initial context group during connection.
+
+### Example: Joining a Default Context Group
+
+```typescript
+// Specify an interopConfig with a specific provider ID and a context group to initialize the `fin.me.interop` client on connection.
+const fin = await connect({
+    options: { brokerUrl, interopConfig: { providerId: 'provider-id', currentContextGroup: 'red' } }
+});
+
+// The fin.me.interop client adds a context handler which will receive updates published on the `red` context group.
+fin.me.interop.addContextHandler((context) => console.log('received context'));
+```
+
+## Initializing FDC3
+
+This library does not produce any global variables. To leverage FDC3 you may use the `.getFDC3` or `.getFDC3Sync` apis of a connected `InteropClient`. (Note that with an interop config provided in `connect` `fin.me.interop` is instantiated as an `InteropClient`)
+
+Supported versions for `fdc3` are `1.2` or `2.0`.
+
+### Example: Creating an FDC3 Client
+
+```typescript
+import { connect } from '@openfin/core-web';
+
+const brokerUrl = 'http://example.com/web-broker';
+
+// Specify an interopConfig with a specific provider ID and a context group to initialize the `fin.me.interop` client on connection.
+const fin = await connect({
+    options: { brokerUrl, interopConfig: { providerId: 'provider-id', currentContextGroup: 'red' } }
+});
+
+// Set window.fdc3 to an FDC3 2.0 DesktopAgent which is connected to the `provider-id` InteropBroker on the `red' channel.
+window.fdc3 = fin.me.interop.getFDC3Sync('2.0');
+```
+
+Note that FDC3 support in web is currently limited to context sharing on system channels.
+
+## Context Aware Connections and Connection Inheritance
+
+`@openfin/core-web` has been designed to support inheritance of brokerUrls and interop configurations if your content is running as a View within an OpenFin Layout. This allows content developers to develop platform-agnostic experiences and ensure that they are able to interact with other content connected to the same Web Broker.
+
+## API Reference
+
+(Please note, this link works in your IDE and not on npmjs.com, we will update this soon.)
+
+- [@openfin/core-web](../out/docs/@openfin/core-web/README.md)
+
+## See Also
+
+- [Fin API reference](https://developer.openfin.co/docs/javascript/stable)
+- [OpenFin Container Developer guide](https://developers.openfin.co/of-docs/docs/container-overview)

package/out/api-client.d.ts

@@ -0,0 +1,140 @@
+import type OpenFin from '@openfin/core';
+
+export declare type BaseConfig = {
+    /**
+     * Options used to initialize Web Layouts related features. If omitted, calling `fin.Platform.Layout.init()`
+     * will not work.
+     */
+    platform?: WebLayoutPlatformOptions;
+};
+
+export declare type BaseConnectionOptions = {
+    /**
+     * The URL of the Web Interop broker to connect to.
+     */
+    brokerUrl: string;
+    /**
+     * Tears down and cancels the connection attempt if it is not complete within the specified timeout (in ms).
+     */
+    timeout?: number;
+    /**
+     * Interop options to use to generate an interop client in `fin.me.interop`
+     */
+    interopConfig?: Partial<OpenFin.InteropConfig>;
+};
+
+/**
+ * ## connect(connectConfig: ConnectConfig)
+ * Establishes a connection to an OpenFin Web Interop Broker, returning a fin object that supports a subset of APIS.
+ *
+ * ### Supported APIs
+ *
+ * * fin.InterApplicationBus.Channels
+ * * fin.Interop
+ * * fin.me.identity
+ * * fin.Platform.Layout.init
+ * * fin.Platform.Layout.create
+ * * fin.Platform.Layout.destroy
+ * * fin.Platform.Layout.getCurrentLayoutManagerSync
+ *
+ * @param connectConfig Config used to initialise the connection
+ * @returns Fin api object
+ * @throws If the connection to the broker fails.
+ * @throws If the connection elapses the configured timeout
+ * @throws If the provided {@link InheritModeConnectConfig.validateOptions} returns false
+ * @throws If connection inheritance is enabled but the current browsing context is not rendered as a View within an OpenFin WebLayout and no {@link ConnectConfig.options} are provided.
+ * @throws If a platform object is provided but the layoutSnapshot is invalid.
+ */
+export declare const connect: (connectConfig: ConnectConfig) => Promise<OpenFin.Fin<'external connection'>>;
+
+export declare type ConnectConfig = StandAloneConnectConfig | InheritModeConnectConfig;
+
+export declare type InheritModeConnectConfig = BaseConfig & {
+    /**
+     * @defaultValue 'disabled'
+     *
+     * If 'enabled', attempts to inherit connection options if it is running as a View within an OpenFin WebLayout.
+     * This means that the `brokerUrl` and `Identity` of the connection will be determined by the WebBroker
+     * of the page where the WebLayout is instantiated via `fin.Platform.Layout.init()` call.
+     *
+     * If 'disabled', the `options` property is required.
+     */
+    connectionInheritance: 'enabled';
+    /**
+     * Options used to connect to an OpenFin Web Broker. Please note, these will be overriden if connectionInheritance
+     * is 'enabled' and supported for the current browsing context. In the case that inherited options are unavailable,
+     * these options will be used.
+     */
+    options?: BaseConnectionOptions;
+    /**
+     * Validates the inherited connection options from the parent browsing context, if available.
+     * @param inheritedOptions Inherited options
+     * @returns True if the connection options are accepted, or false otherwise.
+     */
+    validateOptions?: (inheritedOptions: Omit<BaseConnectionOptions, 'timeout'>) => boolean | Promise<boolean>;
+};
+
+export declare type StandAloneConnectConfig = BaseConfig & {
+    /**
+     * @defaultValue 'disabled'
+     *
+     * If 'enabled', attempts to inherit connection options if it is running as a View within an OpenFin WebLayout.
+     * This means that the `brokerUrl` and `Identity` of the connection will be determined by the WebBroker
+     * of the page where the WebLayout is instantiated via `fin.Platform.Layout.init()` call.
+     *
+     * If 'disabled', the `options` property is required.
+     */
+    connectionInheritance?: 'disabled';
+    /**
+     * Options used to connect to an OpenFin Web Broker. Mandatory if {@link StandAloneConnectConfig.connectionInheritance} is 'disabled'.
+     */
+    options: BaseConnectionOptions;
+};
+
+export declare type WebCreateLayoutOptions = Omit<OpenFin.CreateLayoutOptions, 'layout'> & {
+    layout: WebLayoutOptions;
+};
+
+declare type WebLayoutColumn = OpenFin.LayoutColumn & WebLayoutItemConfig;
+
+/**
+ * Web-only component supplied to IframeViewComponent as it's config
+ */
+export declare type WebLayoutComponent = OpenFin.LayoutComponent & {
+    componentState?: OpenFin.LayoutComponent['componentState'] & {
+        web?: WebState;
+    };
+};
+
+declare type WebLayoutContent = Array<WebLayoutItemConfig | WebLayoutRow | WebLayoutColumn | WebLayoutComponent>;
+
+export declare type WebLayoutInitOptions = Omit<OpenFin.InitLayoutOptions, 'layoutManagerOverride'> & {
+    layoutManagerOverride?: OpenFin.LayoutManagerOverride<WebLayoutSnapshot>;
+};
+
+declare type WebLayoutItemConfig = Omit<OpenFin.LayoutItemConfig, 'content'> & {
+    content?: WebLayoutContent;
+};
+
+export declare type WebLayoutOptions = Omit<OpenFin.LayoutOptions, 'content'> & {
+    content?: WebLayoutContent;
+};
+
+export declare type WebLayoutPlatformOptions = {
+    layoutSnapshot: WebLayoutSnapshot;
+};
+
+declare type WebLayoutRow = OpenFin.LayoutRow & WebLayoutItemConfig;
+
+export declare type WebLayoutSnapshot = {
+    layouts: Record<string, WebLayoutOptions>;
+};
+
+/**
+ * Web-only component state
+ */
+declare type WebState = {
+    frameName?: string;
+};
+
+export { }

package/out/api-client.js

@@ -0,0 +1 @@
+"use strict";var e=require("./main-77c8e2cd.js");require("buffer/"),require("uuid"),require("events"),require("lodash"),exports.connect=e.connect;

package/out/docs/@openfin/core-web/README.md

@@ -0,0 +1,49 @@
+**@openfin/core-web** • [API](../../README.md)
+
+***
+
+[@openfin/core-web](../../README.md) / @openfin/core-web
+
+# @openfin/core-web
+
+The main entry point for leveraging OpenFin Web Interop in a web application.
+
+## Remarks
+
+This module provides a way to connect to an OpenFin Web Interop broker, which allows for communication between Web applications.
+
+## Example
+
+```ts
+import { connect } from '@openfin/core-web';
+
+const fin = await connect({
+   options: {
+      brokerUrl: 'ws://localhost:9696/broker'
+      interopConfig: {
+         providerId: 'my-provider-id',
+         currentContextGroup: 'my-context-group'
+     }
+  }
+ });
+```
+
+## Index
+
+### Type Aliases
+
+- [BaseConfig](type-aliases/BaseConfig.md)
+- [BaseConnectionOptions](type-aliases/BaseConnectionOptions.md)
+- [ConnectConfig](type-aliases/ConnectConfig.md)
+- [InheritModeConnectConfig](type-aliases/InheritModeConnectConfig.md)
+- [StandAloneConnectConfig](type-aliases/StandAloneConnectConfig.md)
+- [WebCreateLayoutOptions](type-aliases/WebCreateLayoutOptions.md)
+- [WebLayoutComponent](type-aliases/WebLayoutComponent.md)
+- [WebLayoutInitOptions](type-aliases/WebLayoutInitOptions.md)
+- [WebLayoutOptions](type-aliases/WebLayoutOptions.md)
+- [WebLayoutPlatformOptions](type-aliases/WebLayoutPlatformOptions.md)
+- [WebLayoutSnapshot](type-aliases/WebLayoutSnapshot.md)
+
+### Functions
+
+- [connect](functions/connect.md)

package/out/docs/@openfin/core-web/functions/connect.md

@@ -0,0 +1,54 @@
+**@openfin/core-web** • [API](../../../README.md)
+
+***
+
+[@openfin/core-web](../../../README.md) / [@openfin/core-web](../README.md) / connect
+
+# Function: connect()
+
+> **connect**(`connectConfig`): `Promise`\<`Fin`\<`"external connection"`\>\>
+
+## connect(connectConfig: ConnectConfig)
+Establishes a connection to an OpenFin Web Interop Broker, returning a fin object that supports a subset of APIS.
+
+### Supported APIs
+
+* fin.InterApplicationBus.Channels
+* fin.Interop
+* fin.me.identity
+* fin.Platform.Layout.init
+* fin.Platform.Layout.create
+* fin.Platform.Layout.destroy
+* fin.Platform.Layout.getCurrentLayoutManagerSync
+
+## Parameters
+
+• **connectConfig**: [`ConnectConfig`](../type-aliases/ConnectConfig.md)
+
+Config used to initialise the connection
+
+## Returns
+
+`Promise`\<`Fin`\<`"external connection"`\>\>
+
+Fin api object
+
+## Throws
+
+If the connection to the broker fails.
+
+## Throws
+
+If the connection elapses the configured timeout
+
+## Throws
+
+If the provided InheritModeConnectConfig.validateOptions returns false
+
+## Throws
+
+If connection inheritance is enabled but the current browsing context is not rendered as a View within an OpenFin WebLayout and no ConnectConfig.options are provided.
+
+## Throws
+
+If a platform object is provided but the layoutSnapshot is invalid.

package/out/docs/@openfin/core-web/iframe-broker/README.md

@@ -0,0 +1,35 @@
+**@openfin/core-web** • [API](../../../README.md)
+
+***
+
+[@openfin/core-web](../../../README.md) / @openfin/core-web/iframe-broker
+
+# @openfin/core-web/iframe-broker
+
+This module is the entry point for the Iframe Broker. It is responsible for initializing the OpenFin Web Interop environment.
+
+## Remarks
+
+This module is intended to be used in an iframe context, and is responsible for setting up the connection between the iframe and the OpenFin Web Interop broker.
+This module requires hosting the script exported by the module:@openfin/core-web/worker module.
+
+## Example
+
+```ts
+import { init } from '@openfin/core-web/iframe-broker';
+
+init({
+  sharedWorkerUrl: 'path to shared worker script'
+});
+```
+
+## Index
+
+### Type Aliases
+
+- [ConnectionOptions](type-aliases/ConnectionOptions.md)
+
+### Functions
+
+- [init](functions/init.md)
+- [rejectConnections](functions/rejectConnections.md)