open-index/open-npm huggingface dataset:
npm package: @morgan-stanley/composeui-fdc3
Description: FDC3 DesktopAgent implementation for Compose UI
Author: Morgan Stanley
Latest version: 0.1.0-alpha.12

<!-- Morgan Stanley makes this available to you under the Apache License, Version 2.0 (the "License"). You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0. See the NOTICE file distributed with this work for additional information regarding copyright ownership. Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. -->

# composeui-fdc3

`composeui-fdc3` is a TypeScript/JavaScript package that provides [FDC3](https://fdc3.finos.org/) support for [ComposeUI](https://morganstanley.github.io/ComposeUI/) applications. It enables interoperability between desktop applications by implementing the FDC3 standard APIs for context sharing, intent handling, and application discovery.

**Note:** This package currently supports only FDC3 version 2.0.  
It uses the [Messaging abstractions TypeScript library](https://github.com/morganstanley/ComposeUI/tree/main/src/messaging/js/composeui-messaging-abstractions) as its messaging layer.

## Features

- Implements FDC3 APIs for context, intents, and app channels
- TypeScript typings included

## Installation

You need to embed the generated bundle into your shell application, similar to how it is handled in the current Shell POC. In that example, a .NET WPF application includes the bundle as an embedded resource. When using WebView2 to load web windows, the application initializes the bundle as a script and injects it into the page.

To use the FDC3 APIs, install the official FINOS FDC3 library (version 2.0) in your application:

```sh
npm install @finos/fdc3@2.0.0
```

## Usage

Import and use the FDC3 API in your application as needed.

```typescript
// Raise an intent
fdc3.raiseIntent('ViewChart', { instrument: { type: 'fdc3.instrument', id: { ticker: 'AAPL' } } });

// Broadcast context
fdc3.broadcast({ type: 'fdc3.contact', name: 'Jane Doe' });

// Listen for context
fdc3.addContextListener('fdc3.instrument', context => {
  console.log('Received instrument context:', context);
});
```

## API

This package implements the [FDC3 2.0+ API](https://fdc3.finos.org/docs/2.0/api/spec). See the FDC3 documentation for details on available methods and context types.

## Setup

- Have a Shell bundling the generated resource into the webpage.
- Import and use the FDC3 API from the FINOS library as shown above.
- Ensure your environment is configured to support FDC3 interoperability, e.g., having the FDC3 DesktopAgent backend for handling the requests.

## Documentation

- [FDC3 Standard](https://fdc3.finos.org/)
- [ComposeUI Documentation](https://morganstanley.github.io/ComposeUI/)

&copy; Morgan Stanley. See NOTICE file for additional information.
npm package: @morgan-stanley/composeui-messaging-abstractions
Description: TypeScript abstractions library for ComposeUI's messaging
Author: Morgan Stanley
Latest version: 0.1.0-alpha.12

# @morgan-stanley/composeui-messaging-abstractions

Messaging helpers that wrap a lower‑level IMessaging abstraction (publish/subscribe plus request/response). Provides simple, typed APIs for sending and receiving structured data as JSON without duplicating serialization logic in callers. Provides JSON focused extension methods available using the `JsonMessaging` class.

## Features

- Thin adapter: JsonMessaging delegates to any IMessaging implementation.
- Typed publish/subscribe via JSON (subscribeJson / publishJson).
- Typed request/response services (registerJsonService / invokeJsonService / invokeJsonServiceNoRequest).
- Automatic serialization/deserialization.
- String short‑circuit: if a typed service handler returns a string it is passed through without double JSON.stringify.

## Installation

Install as a workspace dependency

```bash
npm install @morgan-stanley/composeui-messaging-abstractions
```

## Usage
Implement the `IMessaging` API to declare your own communication.

```typescript
import { IMessaging } from "@morgan-stanley/composeui-messaging-abstractions";
import { HubConnection } from '@microsoft/signalr';

export class MyMessaging implements IMessaging {
    constructor(private readonly signalRMessaging: MySignalWrapper) {}
    //Implement the IMessging API...
}
```

## Module format

Rollup emits dual builds:
- ES Module: dist/index.js
- CommonJS: dist/index.cjs

 package.json exports map require to CJS and import to ESM. Use:
```typescript
// CJS
const { JsonMessaging } = require('@morgan-stanley/composeui-messaging-abstractions');

// ESM / TypeScript
import { JsonMessaging } from '@morgan-stanley/composeui-messaging-abstractions';
```

## Dependencies

Runtime:
- rxjs (Unsubscribable type)

Build / Dev:
- typescript
- @rollup/plugin-typescript
- @rollup/plugin-node-resolve

## License

Apache-2.0 (see NOTICE and LICENSE files).

## Documentation

- [FDC3 Standard](https://fdc3.finos.org/)
- [ComposeUI Documentation](https://morganstanley.github.io/ComposeUI/)

&copy; Morgan Stanley. See NOTICE file for additional information.
npm package: @morgan-stanley/fdc3-web
Description: The FDC3 library is a powerful tool for building interoperable financial desktop applications based on the FINOS defined standard. It provides a set of APIs and protocols that enable seamless communication and data sharing between different applications w
Author: Morgan Stanley
Latest version: 0.11.2

# FDC3 Library

The FDC3 library is a powerful tool for building interoperable financial desktop applications based on the FINOS defined standard. It provides a set of APIs and protocols that enable seamless communication and data sharing between different applications within the financial ecosystem.

## Features

- **Contextual Data Sharing**: The FDC3 library allows applications to share context data, such as instrument details, user preferences, and workspace layouts, with other applications in a consistent and efficient manner.

- **Intent-based Communication**: With FDC3, applications can communicate with each other using intents, which represent high-level user actions. This enables applications to discover and launch relevant functionality in other applications, enhancing user productivity.

- **App Directory**: The library includes an app directory that provides a centralized registry of financial applications. Developers can leverage this directory to discover and integrate with other applications in the ecosystem.

## Example Usage

```typescript
import { DesktopAgentFactory } from '@morgan-stanley/fdc3-web';
import { rootWindowMessagingProviderFactory } from '@morgan-stanley/fdc3-web-messaging-provider';

const desktopAgentFactory = new DesktopAgentFactory();

// If in the root window of the application create the Root Desktop Agent
const fdc3 = desktopAgentFactory.createRoot('my-application', rootWindowMessagingProviderFactory)
```

```typescript
import { DesktopAgentFactory } from '@morgan-stanley/fdc3-web';
import { iframeMessagingProviderFactory } from '@morgan-stanley/fdc3-web-messaging-provider';

const desktopAgentFactory = new DesktopAgentFactory();

// If in the child window or Iframe of the application create a Proxy Desktop Agent
const fdc3 = desktopAgentFactory.createProxy('my-child-application', iframeMessagingProviderFactory)
```

```typescript
// Launch an application with a specific intent
fdc3.open('chart', { instrument: 'AAPL' });

// Share context data with other applications
fdc3.broadcast({ instrument: 'AAPL', timeframe: '1D' });

// Subscribe to context updates from other applications
fdc3.subscribe('instrument', (context) => {
    console.log('Received instrument update:', context);
});
```

## Development and Contribution

To contribute to the FDC3 library and its plugins, follow these steps:

1. Fork the repository on GitHub.
2. Clone the forked repository to your local machine.
3. Install the required dependencies using `npm install`.
4. Make your changes and ensure that the full build is executing successfully with `npm run build:release`.
5. Submit a pull request with your changes, providing a clear description of the modifications made.

We welcome contributions from the community and appreciate your efforts in improving the FDC3 library.
npm package: @morgan-stanley/fdc3-web-messaging-provider
Description: The FDC3 Messaging Provider plugin is a library used to facilitate low-level communications between HTML5 windows and iFrames used as a plugin to the main `@morgan-stanley/fdc3-web` library. It provides two types of messaging providers: the Root Window Me
Author: Morgan Stanley
Latest version: 0.11.2

# FDC3 Messaging Provider Plugin

The FDC3 Messaging Provider plugin is a library used to facilitate low-level communications between HTML5 windows and iFrames used as a plugin to the main `@morgan-stanley/fdc3-web` library. It provides two types of messaging providers: the Root Window Messaging Provider and the iFrame Messaging Provider.

## Root Window Messaging Provider

The Root Window Messaging Provider is designed to be used in the main application window. It allows for communication between the main window and any child windows or iFrames.

To use the Root Window Messaging Provider, follow these steps:

Import the messaging provider module and pass the `rootWindowMessagingProviderFactory` to the `DesktopAgentFactory.createRoot` function:

```javascript
import { DesktopAgentFactory } from '@morgan-stanley/fdc3-web';
import { rootWindowMessagingProviderFactory } from '@morgan-stanley/fdc3-web-messaging-provider';

const desktopAgentFactory = new DesktopAgentFactory();

// If in the root window of the application create the Root Desktop Agent
const fdc3 = desktopAgentFactory.createRoot('my-application', rootWindowMessagingProviderFactory)
```

## iFrame Messaging Provider

The iFrame Messaging Provider is designed to be used in windows that are children of the main application. It allows for communication between the iFrame and the main window.

To use the iFrame Messaging Provider, follow these steps:

Import the messaging provider module and pass the `iframeMessagingProviderFactory` to the `DesktopAgentFactory.createProxy` function:

```typescript
import { DesktopAgentFactory } from '@morgan-stanley/fdc3-web';
import { iframeMessagingProviderFactory } from '@morgan-stanley/fdc3-web-messaging-provider';

const desktopAgentFactory = new DesktopAgentFactory();

// If in the child window or frame of the application create a Proxy Desktop Agent
const fdc3 = desktopAgentFactory.createProxy('my-child-application', iframeMessagingProviderFactory)
```
npm package: @morgan-stanley/fdc3-web-ui-provider
Description: The FDC3 UI Provider plugin is a powerful addition to the FDC3 library that enhances the user experience by providing a Resolver UI and a colored channel selector UI.
Author: Morgan Stanley
Latest version: 0.11.2

# FDC3 UI Provider Plugin

The FDC3 UI Provider plugin is a powerful addition to the FDC3 library that enhances the user experience by providing a Resolver UI and a colored channel selector UI.

## Resolver UI
The Resolver UI allows users to easily select the target application for an Intent or Context. It simplifies the process of choosing the appropriate application to handle specific actions, improving efficiency and user satisfaction.

## Colored Channel Selector UI
The UI Provider plugin also includes a colored channel selector UI. This feature enables multiple applications to share broadcast context events. Users can easily identify and interact with different channels, enhancing collaboration and communication within the FDC3 ecosystem.

## Customizable Componentry
The UI Provider componentry is built with Lit, a lightweight and efficient web component library. It is fully customizable, allowing developers to seamlessly integrate it with their applications. The UI can be easily themed to match the host application's aesthetics, ensuring a consistent and cohesive user experience.

## Example Usage

To configure the `AppResolverComponent` on the `DesktopAgent` when calling `DesktopAgentFactory.createRoot`, follow these steps:

1. Import the necessary modules:
```typescript
import { DesktopAgentFactory, DesktopAgent } from '@morgan-stanley/fdc3-web';
import { rootWindowMessagingProviderFactory } from '@morgan-stanley/fdc3-web-messaging-provider';

const desktopAgentFactory = new DesktopAgentFactory();
```

2. Configure the `DesktopAgent` with the `AppResolverComponent`:
```typescript
const fdc3 = desktopAgentFactory.createRoot('my-application',
    rootWindowMessagingProviderFactory,
    (agent: DesktopAgent) => Promise.resolve(new AppResolverComponent(document, agent))
    )
```

5. The user will now be presented a Resolver UI to resolve intents within your application.
npm package: @morgan-stanley/message-broker
Description: Framework agnostic messageBroker for decoupled communication.
Author: Morgan Stanley
Latest version: 2.0.0

# MessageBroker

![Lifecycle Active](https://badgen.net/badge/Lifecycle/Active/green)
![NPM](https://img.shields.io/npm/l/@morgan-stanley/message-broker)
![npm](https://img.shields.io/npm/v/@morgan-stanley/message-broker)
![NPM](https://img.shields.io/badge/types-TypeScript-blue)
[![Build Status](https://github.com/morganstanley/message-broker/actions/workflows/build.yml/badge.svg)](https://github.com/morganstanley/message-broker/actions/workflows/build.yml)
[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/morganstanley/message-broker/badge)](https://securityscorecards.dev/viewer/?uri=github.com/morganstanley/message-broker)

MessageBroker provides framework agnostic, decoupled communication between publishers and subscribers. This library is fully type safe and works in both browsers and Node.js. MessageBroker is built ontop of [RxJS](https://rxjs.dev/guide/overview) providing access to observables and a comprehensive list of operators.

Full documentation can be found at https://morganstanley.github.io/message-broker/

## Basic Usage

First, install the message-broker

```bash
npm install @morgan-stanley/message-broker
```

then you can start sending and receiving messages like this

```typescript
import { messageBroker, IMessageBroker } from '@morgan-stanley/message-broker';

interface IContracts {
    myChannel: {
        payload: string;
    };
}

const broker: IMessageBroker<IContracts> = messageBroker<IContracts>();

broker.get('myChannel').subscribe((message) => {
    console.log(message.payload);
});

broker.create('myChannel').publish({
    payload: 'My first message using the MessageBroker!',
});
```

## Development

For guidelines on how to contribute please click [here](./CONTRIBUTING.md).
Here are a list of commands to run if you are interested in developing or contributing to the project.

```typescript

npm install // Install all package dependencies.

npm run test // Run tests on the command line.

npm run watch-test // Run tests in watch mode.

npm run lint // Checks the code for lint errors.

npm run build // Run a simple build.

npm run watch-build // Run build in watch mode.

npm run build-release // Run a full build (Compile, Tests, Lint).

```