@genesislcap/foundation-fdc3 14.199.3-alpha-40ecfcd.0 → 14.200.0-FUI-2127.3

package/dist/dts/util/fdc3-system-channel-listener.d.ts

@@ -0,0 +1,348 @@
+import { FoundationElement } from '@genesislcap/web-core';
+import { FDC3 } from '../fdc3';
+/**
+ * System channel listener config. System channels are also known as color channels
+ * @alpha
+ * @param channelType - string for the context channel type
+ * @param callback - function that is called if a message with a matching context is emitted
+ */
+export interface SystemChannelListenerConfig {
+    channelType: string;
+    callback: (any: any) => void;
+}
+declare const Fdc3SystemChannelListener_base: (new (...args: any[]) => {
+    "__#1@#_container": import("@genesislcap/foundation-utils").FoundationLayoutContainer | import("@genesislcap/foundation-utils").LayoutCacheContainer | import("@genesislcap/foundation-utils").DOMContainer;
+    "__#1@#_latestTokenCode": string;
+    "__#1@#_hasFirstLoaded": boolean;
+    "__#1@#_cleanupTimeout": NodeJS.Timeout;
+    "__#1@#_shouldForceLifecycle": boolean;
+    cloneNode(deep?: boolean): Node;
+    deepClone(): Node;
+    readonly shouldRunDisconnect: boolean;
+    readonly shouldRunConnect: boolean;
+    "__#1@#_blockLifecycleDueToTokenChange"(lifecycleType: "connect" | "disconnect" | "reconnect"): boolean;
+    "__#1@#_tryFindContainingLayout"(e: Element): import("@genesislcap/foundation-utils").FoundationLayoutContainer | import("@genesislcap/foundation-utils").LayoutCacheContainer | import("@genesislcap/foundation-utils").DOMContainer;
+    connectedCallback(): void;
+    readonly $fastController: import("@microsoft/fast-element").Controller;
+    $emit(type: string, detail?: any, options?: Omit<CustomEventInit<any>, "detail">): boolean | void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string, newValue: string): void;
+    accessKey: string;
+    readonly accessKeyLabel: string;
+    autocapitalize: string;
+    dir: string;
+    draggable: boolean;
+    hidden: boolean;
+    inert: boolean;
+    innerText: string;
+    lang: string;
+    readonly offsetHeight: number;
+    readonly offsetLeft: number;
+    readonly offsetParent: Element;
+    readonly offsetTop: number;
+    readonly offsetWidth: number;
+    outerText: string;
+    spellcheck: boolean;
+    title: string;
+    translate: boolean;
+    attachInternals(): ElementInternals;
+    click(): void;
+    addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K_1 extends keyof HTMLElementEventMap>(type: K_1, listener: (this: HTMLElement, ev: HTMLElementEventMap[K_1]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    readonly attributes: NamedNodeMap;
+    readonly classList: DOMTokenList;
+    className: string;
+    readonly clientHeight: number;
+    readonly clientLeft: number;
+    readonly clientTop: number;
+    readonly clientWidth: number;
+    id: string;
+    readonly localName: string;
+    readonly namespaceURI: string;
+    onfullscreenchange: (this: Element, ev: Event) => any;
+    onfullscreenerror: (this: Element, ev: Event) => any;
+    outerHTML: string;
+    readonly ownerDocument: Document;
+    readonly part: DOMTokenList;
+    readonly prefix: string;
+    readonly scrollHeight: number;
+    scrollLeft: number;
+    scrollTop: number;
+    readonly scrollWidth: number;
+    readonly shadowRoot: ShadowRoot;
+    slot: string;
+    readonly tagName: string;
+    attachShadow(init: ShadowRootInit): ShadowRoot;
+    closest<K_2 extends keyof HTMLElementTagNameMap>(selector: K_2): HTMLElementTagNameMap[K_2];
+    closest<K_3 extends keyof SVGElementTagNameMap>(selector: K_3): SVGElementTagNameMap[K_3];
+    closest<E extends Element = Element>(selectors: string): E;
+    getAttribute(qualifiedName: string): string;
+    getAttributeNS(namespace: string, localName: string): string;
+    getAttributeNames(): string[];
+    getAttributeNode(qualifiedName: string): Attr;
+    getAttributeNodeNS(namespace: string, localName: string): Attr;
+    getBoundingClientRect(): DOMRect;
+    getClientRects(): DOMRectList;
+    getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
+    getElementsByTagName<K_4 extends keyof HTMLElementTagNameMap>(qualifiedName: K_4): HTMLCollectionOf<HTMLElementTagNameMap[K_4]>;
+    getElementsByTagName<K_5 extends keyof SVGElementTagNameMap>(qualifiedName: K_5): HTMLCollectionOf<SVGElementTagNameMap[K_5]>;
+    getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
+    getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
+    getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
+    getElementsByTagNameNS(namespace: string, localName: string): HTMLCollectionOf<Element>;
+    hasAttribute(qualifiedName: string): boolean;
+    hasAttributeNS(namespace: string, localName: string): boolean;
+    hasAttributes(): boolean;
+    hasPointerCapture(pointerId: number): boolean;
+    insertAdjacentElement(where: InsertPosition, element: Element): Element;
+    insertAdjacentHTML(position: InsertPosition, text: string): void;
+    insertAdjacentText(where: InsertPosition, data: string): void;
+    matches(selectors: string): boolean;
+    releasePointerCapture(pointerId: number): void;
+    removeAttribute(qualifiedName: string): void;
+    removeAttributeNS(namespace: string, localName: string): void;
+    removeAttributeNode(attr: Attr): Attr;
+    requestFullscreen(options?: FullscreenOptions): Promise<void>;
+    requestPointerLock(): void;
+    scroll(options?: ScrollToOptions): void;
+    scroll(x: number, y: number): void;
+    scrollBy(options?: ScrollToOptions): void;
+    scrollBy(x: number, y: number): void;
+    scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
+    scrollTo(options?: ScrollToOptions): void;
+    scrollTo(x: number, y: number): void;
+    setAttribute(qualifiedName: string, value: string): void;
+    setAttributeNS(namespace: string, qualifiedName: string, value: string): void;
+    setAttributeNode(attr: Attr): Attr;
+    setAttributeNodeNS(attr: Attr): Attr;
+    setPointerCapture(pointerId: number): void;
+    toggleAttribute(qualifiedName: string, force?: boolean): boolean;
+    webkitMatchesSelector(selectors: string): boolean;
+    readonly baseURI: string;
+    readonly childNodes: NodeListOf<ChildNode>;
+    readonly firstChild: ChildNode;
+    readonly isConnected: boolean;
+    readonly lastChild: ChildNode;
+    readonly nextSibling: ChildNode;
+    readonly nodeName: string;
+    readonly nodeType: number;
+    nodeValue: string;
+    readonly parentElement: HTMLElement;
+    readonly parentNode: ParentNode;
+    readonly previousSibling: ChildNode;
+    textContent: string;
+    appendChild<T_1 extends Node>(node: T_1): T_1;
+    compareDocumentPosition(other: Node): number;
+    contains(other: Node): boolean;
+    getRootNode(options?: GetRootNodeOptions): Node;
+    hasChildNodes(): boolean;
+    insertBefore<T_2 extends Node>(node: T_2, child: Node): T_2;
+    isDefaultNamespace(namespace: string): boolean;
+    isEqualNode(otherNode: Node): boolean;
+    isSameNode(otherNode: Node): boolean;
+    lookupNamespaceURI(prefix: string): string;
+    lookupPrefix(namespace: string): string;
+    normalize(): void;
+    removeChild<T_3 extends Node>(child: T_3): T_3;
+    replaceChild<T_4 extends Node>(node: Node, child: T_4): T_4;
+    readonly ATTRIBUTE_NODE: number;
+    readonly CDATA_SECTION_NODE: number;
+    readonly COMMENT_NODE: number;
+    readonly DOCUMENT_FRAGMENT_NODE: number;
+    readonly DOCUMENT_NODE: number;
+    readonly DOCUMENT_POSITION_CONTAINED_BY: number;
+    readonly DOCUMENT_POSITION_CONTAINS: number;
+    readonly DOCUMENT_POSITION_DISCONNECTED: number;
+    readonly DOCUMENT_POSITION_FOLLOWING: number;
+    readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: number;
+    readonly DOCUMENT_POSITION_PRECEDING: number;
+    readonly DOCUMENT_TYPE_NODE: number;
+    readonly ELEMENT_NODE: number;
+    readonly ENTITY_NODE: number;
+    readonly ENTITY_REFERENCE_NODE: number;
+    readonly NOTATION_NODE: number;
+    readonly PROCESSING_INSTRUCTION_NODE: number;
+    readonly TEXT_NODE: number;
+    dispatchEvent(event: Event): boolean;
+    ariaAtomic: string;
+    ariaAutoComplete: string;
+    ariaBusy: string;
+    ariaChecked: string;
+    ariaColCount: string;
+    ariaColIndex: string;
+    ariaColIndexText: string;
+    ariaColSpan: string;
+    ariaCurrent: string;
+    ariaDisabled: string;
+    ariaExpanded: string;
+    ariaHasPopup: string;
+    ariaHidden: string;
+    ariaInvalid: string;
+    ariaKeyShortcuts: string;
+    ariaLabel: string;
+    ariaLevel: string;
+    ariaLive: string;
+    ariaModal: string;
+    ariaMultiLine: string;
+    ariaMultiSelectable: string;
+    ariaOrientation: string;
+    ariaPlaceholder: string;
+    ariaPosInSet: string;
+    ariaPressed: string;
+    ariaReadOnly: string;
+    ariaRequired: string;
+    ariaRoleDescription: string;
+    ariaRowCount: string;
+    ariaRowIndex: string;
+    ariaRowIndexText: string;
+    ariaRowSpan: string;
+    ariaSelected: string;
+    ariaSetSize: string;
+    ariaSort: string;
+    ariaValueMax: string;
+    ariaValueMin: string;
+    ariaValueNow: string;
+    ariaValueText: string;
+    role: string;
+    animate(keyframes: PropertyIndexedKeyframes | Keyframe[], options?: number | KeyframeAnimationOptions): Animation;
+    getAnimations(options?: GetAnimationsOptions): Animation[];
+    after(...nodes: (string | Node)[]): void;
+    before(...nodes: (string | Node)[]): void;
+    remove(): void;
+    replaceWith(...nodes: (string | Node)[]): void;
+    innerHTML: string;
+    readonly nextElementSibling: Element;
+    readonly previousElementSibling: Element;
+    readonly childElementCount: number;
+    readonly children: HTMLCollection;
+    readonly firstElementChild: Element;
+    readonly lastElementChild: Element;
+    append(...nodes: (string | Node)[]): void;
+    prepend(...nodes: (string | Node)[]): void;
+    querySelector<K_6 extends keyof HTMLElementTagNameMap>(selectors: K_6): HTMLElementTagNameMap[K_6];
+    querySelector<K_7 extends keyof SVGElementTagNameMap>(selectors: K_7): SVGElementTagNameMap[K_7];
+    querySelector<E_1 extends Element = Element>(selectors: string): E_1;
+    querySelectorAll<K_8 extends keyof HTMLElementTagNameMap>(selectors: K_8): NodeListOf<HTMLElementTagNameMap[K_8]>;
+    querySelectorAll<K_9 extends keyof SVGElementTagNameMap>(selectors: K_9): NodeListOf<SVGElementTagNameMap[K_9]>;
+    querySelectorAll<E_2 extends Element = Element>(selectors: string): NodeListOf<E_2>;
+    replaceChildren(...nodes: (string | Node)[]): void;
+    readonly assignedSlot: HTMLSlotElement;
+    oncopy: (this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any;
+    oncut: (this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any;
+    onpaste: (this: DocumentAndElementEventHandlers, ev: ClipboardEvent) => any;
+    readonly style: CSSStyleDeclaration;
+    contentEditable: string;
+    enterKeyHint: string;
+    inputMode: string;
+    readonly isContentEditable: boolean;
+    onabort: (this: GlobalEventHandlers, ev: UIEvent) => any;
+    onanimationcancel: (this: GlobalEventHandlers, ev: AnimationEvent) => any;
+    onanimationend: (this: GlobalEventHandlers, ev: AnimationEvent) => any;
+    onanimationiteration: (this: GlobalEventHandlers, ev: AnimationEvent) => any;
+    onanimationstart: (this: GlobalEventHandlers, ev: AnimationEvent) => any;
+    onauxclick: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onbeforeinput: (this: GlobalEventHandlers, ev: InputEvent) => any;
+    onblur: (this: GlobalEventHandlers, ev: FocusEvent) => any;
+    oncancel: (this: GlobalEventHandlers, ev: Event) => any;
+    oncanplay: (this: GlobalEventHandlers, ev: Event) => any;
+    oncanplaythrough: (this: GlobalEventHandlers, ev: Event) => any;
+    onchange: (this: GlobalEventHandlers, ev: Event) => any;
+    onclick: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onclose: (this: GlobalEventHandlers, ev: Event) => any;
+    oncontextmenu: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    oncuechange: (this: GlobalEventHandlers, ev: Event) => any;
+    ondblclick: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    ondrag: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragend: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragenter: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragleave: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragover: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondragstart: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondrop: (this: GlobalEventHandlers, ev: DragEvent) => any;
+    ondurationchange: (this: GlobalEventHandlers, ev: Event) => any;
+    onemptied: (this: GlobalEventHandlers, ev: Event) => any;
+    onended: (this: GlobalEventHandlers, ev: Event) => any;
+    onerror: OnErrorEventHandlerNonNull;
+    onfocus: (this: GlobalEventHandlers, ev: FocusEvent) => any;
+    onformdata: (this: GlobalEventHandlers, ev: FormDataEvent) => any;
+    ongotpointercapture: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    oninput: (this: GlobalEventHandlers, ev: Event) => any;
+    oninvalid: (this: GlobalEventHandlers, ev: Event) => any;
+    onkeydown: (this: GlobalEventHandlers, ev: KeyboardEvent) => any;
+    onkeypress: (this: GlobalEventHandlers, ev: KeyboardEvent) => any;
+    onkeyup: (this: GlobalEventHandlers, ev: KeyboardEvent) => any;
+    onload: (this: GlobalEventHandlers, ev: Event) => any;
+    onloadeddata: (this: GlobalEventHandlers, ev: Event) => any;
+    onloadedmetadata: (this: GlobalEventHandlers, ev: Event) => any;
+    onloadstart: (this: GlobalEventHandlers, ev: Event) => any;
+    onlostpointercapture: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onmousedown: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseenter: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseleave: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmousemove: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseout: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseover: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onmouseup: (this: GlobalEventHandlers, ev: MouseEvent) => any;
+    onpause: (this: GlobalEventHandlers, ev: Event) => any;
+    onplay: (this: GlobalEventHandlers, ev: Event) => any;
+    onplaying: (this: GlobalEventHandlers, ev: Event) => any;
+    onpointercancel: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerdown: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerenter: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerleave: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointermove: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerout: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerover: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onpointerup: (this: GlobalEventHandlers, ev: PointerEvent) => any;
+    onprogress: (this: GlobalEventHandlers, ev: ProgressEvent<EventTarget>) => any;
+    onratechange: (this: GlobalEventHandlers, ev: Event) => any;
+    onreset: (this: GlobalEventHandlers, ev: Event) => any;
+    onresize: (this: GlobalEventHandlers, ev: UIEvent) => any;
+    onscroll: (this: GlobalEventHandlers, ev: Event) => any;
+    onsecuritypolicyviolation: (this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any;
+    onseeked: (this: GlobalEventHandlers, ev: Event) => any;
+    onseeking: (this: GlobalEventHandlers, ev: Event) => any;
+    onselect: (this: GlobalEventHandlers, ev: Event) => any;
+    onselectionchange: (this: GlobalEventHandlers, ev: Event) => any;
+    onselectstart: (this: GlobalEventHandlers, ev: Event) => any;
+    onslotchange: (this: GlobalEventHandlers, ev: Event) => any;
+    onstalled: (this: GlobalEventHandlers, ev: Event) => any;
+    onsubmit: (this: GlobalEventHandlers, ev: SubmitEvent) => any;
+    onsuspend: (this: GlobalEventHandlers, ev: Event) => any;
+    ontimeupdate: (this: GlobalEventHandlers, ev: Event) => any;
+    ontoggle: (this: GlobalEventHandlers, ev: Event) => any;
+    ontouchcancel?: (this: GlobalEventHandlers, ev: TouchEvent) => any;
+    ontouchend?: (this: GlobalEventHandlers, ev: TouchEvent) => any;
+    ontouchmove?: (this: GlobalEventHandlers, ev: TouchEvent) => any;
+    ontouchstart?: (this: GlobalEventHandlers, ev: TouchEvent) => any;
+    ontransitioncancel: (this: GlobalEventHandlers, ev: TransitionEvent) => any;
+    ontransitionend: (this: GlobalEventHandlers, ev: TransitionEvent) => any;
+    ontransitionrun: (this: GlobalEventHandlers, ev: TransitionEvent) => any;
+    ontransitionstart: (this: GlobalEventHandlers, ev: TransitionEvent) => any;
+    onvolumechange: (this: GlobalEventHandlers, ev: Event) => any;
+    onwaiting: (this: GlobalEventHandlers, ev: Event) => any;
+    onwebkitanimationend: (this: GlobalEventHandlers, ev: Event) => any;
+    onwebkitanimationiteration: (this: GlobalEventHandlers, ev: Event) => any;
+    onwebkitanimationstart: (this: GlobalEventHandlers, ev: Event) => any;
+    onwebkittransitionend: (this: GlobalEventHandlers, ev: Event) => any;
+    onwheel: (this: GlobalEventHandlers, ev: WheelEvent) => any;
+    autofocus: boolean;
+    readonly dataset: DOMStringMap;
+    nonce?: string;
+    tabIndex: number;
+    blur(): void;
+    focus(options?: FocusOptions): void;
+}) & typeof FoundationElement;
+export declare class Fdc3SystemChannelListener extends Fdc3SystemChannelListener_base {
+    config: SystemChannelListenerConfig[];
+    fdc3: FDC3;
+    deepClone(): Node;
+    connectedCallback(): void;
+    private channelSub;
+    protected addChannelListeners(): void;
+    disconnectedCallback(): void;
+}
+export {};
+//# sourceMappingURL=fdc3-system-channel-listener.d.ts.map

package/dist/dts/util/fdc3-system-channel-listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fdc3-system-channel-listener.d.ts","sourceRoot":"","sources":["../../../src/util/fdc3-system-channel-listener.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAEzE,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE/B;;;;;GAKG;AACH,MAAM,WAAW,2BAA2B;IAC1C,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,CAAC,GAAG,KAAA,KAAK,IAAI,CAAC;CACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED,qBAGa,yBAA0B,SAAQ,8BAAiC;IAC9E,MAAM,EAAE,2BAA2B,EAAE,CAAM;IAErC,IAAI,EAAE,IAAI,CAAC;IAER,SAAS,IAAI,IAAI;IAgB1B,iBAAiB;IAUjB,OAAO,CAAC,UAAU,CAAsB;IAExC,SAAS,CAAC,mBAAmB,IAAI,IAAI;IAarC,oBAAoB;CAIrB"}

package/dist/dts/util/index.d.ts

@@ -1,3 +1,2 @@
 export * from './fdc3-raise-intent';
-export * from './fdc3-listener';
 //# sourceMappingURL=index.d.ts.map

package/dist/dts/util/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/util/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/util/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/esm/fdc3-channel-event.js

@@ -14,7 +14,12 @@ let Fdc3ChannelEvent = class Fdc3ChannelEvent extends LifecycleMixin(FoundationE
             if (this.mappingFunction && typeof this.mappingFunction === 'function') {
                 payload = this.mappingFunction(payload);
             }
-            yield this.fdc3.broadcastOnChannel(this.channelName, this.channelType, payload);
+            if (this.channelName) {
+                yield this.fdc3.broadcastOnChannel(this.channelName, this.channelType, payload);
+            }
+            else {
+                yield this.fdc3.broadcastOnCurrentChannel(payload, this.channelType);
+            }
         });
     }
     connectedCallback() {

package/dist/esm/fdc3.js

@@ -2,9 +2,10 @@ import { __awaiter, __decorate } from "tslib";
 /**
  * See https://fdc3.finos.org/docs/fdc3-intro, and https://github.com/finos/FDC3/tree/master/src/api
  */
-import { addIntentListener, fdc3Ready, findIntent, findIntentsByContext, getCurrentChannel, getOrCreateChannel, getInfo, joinChannel, raiseIntent, raiseIntentForContext, versionIsAtLeast, } from '@finos/fdc3';
+import { addIntentListener, fdc3Ready, findIntent, findIntentsByContext, getCurrentChannel, getOrCreateChannel, joinChannel, raiseIntent, raiseIntentForContext, } from '@finos/fdc3';
 import { observable } from '@microsoft/fast-element';
 import { DI } from '@microsoft/fast-foundation';
+import { ReplaySubject } from 'rxjs';
 import { stripOutBigInt } from './util/fdc3-util';
 import { logger } from './utils';
 /**
@@ -14,14 +15,26 @@ import { logger } from './utils';
 export class DefaultFDC3 {
     constructor() {
         this.isReady = false;
-        this.connect();
+        this._isReady$ = new ReplaySubject();
+        this.isReady$ = this._isReady$.asObservable();
+        this._currentChannel$ = new ReplaySubject();
+        this.currentChannel$ = this._currentChannel$.asObservable();
+        this.isInteropFdc3 = () => !!window.io;
+        this.init();
     }
-    connect() {
+    init() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.isReady) {
+                logger.debug('fdc3 already connected');
+                return;
+            }
             try {
-                this.isReady = false;
                 yield fdc3Ready();
+                this.isReady = true;
+                this._isReady$.next(true);
                 logger.debug('fdc3 connection success');
+                yield this.getAndUpdateCurrentChannel();
+                yield this.handleInteropChannelChanges();
             }
             catch (err) {
                 logger.error('fdc3 connection error', err);
@@ -43,20 +56,32 @@ export class DefaultFDC3 {
         logger.debug(`fdc3 findIntentsByContext '${context}'`);
         return findIntentsByContext(context);
     }
-    raiseIntent(context, intent) {
-        if (getInfo && versionIsAtLeast(getInfo(), '1.2')) {
+    raiseIntentForContext(context) {
+        return __awaiter(this, void 0, void 0, function* () {
             logger.debug(`fdc3 raiseIntentForContext '${context}'`);
             return raiseIntentForContext(context);
-        }
+        });
+    }
+    raiseIntent(context, intent) {
         if (intent) {
             logger.debug(`fdc3 raiseIntent '${intent}' '${context}'`);
             return raiseIntent(intent, context);
         }
-        logger.error(`fdc3 unable to raiseIntent using context '${context}' and intent '${intent}'.`);
+        else {
+            logger.warn(`fdc3 raiseIntent - no intent passed`);
+        }
     }
     joinChannel(channelId) {
-        logger.debug(`fdc3 joinChannel '${channelId}'`);
-        return joinChannel(channelId);
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.debug(`fdc3 joinChannel '${channelId}'`);
+            if (((_a = this._currentChannel) === null || _a === void 0 ? void 0 : _a.id) === channelId) {
+                return;
+            }
+            yield joinChannel(channelId);
+            yield this.getAndUpdateCurrentChannel();
+            return;
+        });
     }
     getOrCreateChannel(channelId) {
         logger.debug(`fdc3 getOrCreateChannel '${channelId}'`);
@@ -65,12 +90,15 @@ export class DefaultFDC3 {
     broadcastOnChannel(channelName, type, payload) {
         return __awaiter(this, void 0, void 0, function* () {
             const channel = yield getOrCreateChannel(channelName);
-            payload = stripOutBigInt(payload);
-            const m = {
-                type,
-                id: payload,
-            };
-            channel.broadcast(m);
+            this.broadcastMessageOnChannel(channel, payload, type);
+        });
+    }
+    broadcastOnCurrentChannel(payload, type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = yield getCurrentChannel();
+            if (channel) {
+                this.broadcastMessageOnChannel(channel, payload, type);
+            }
         });
     }
     broadcastOnChannelEventHandler(channelName, type) {
@@ -90,11 +118,66 @@ export class DefaultFDC3 {
             return channel;
         });
     }
+    addSystemChannelListener(channelType, callback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = yield getCurrentChannel();
+            channel.addContextListener(channelType, callback);
+        });
+    }
     getCurrentChannel() {
         return __awaiter(this, void 0, void 0, function* () {
             return getCurrentChannel();
         });
     }
+    handleChannelCurrentContext(channel, contextType, listenerCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentContextValue = yield channel.getCurrentContext(contextType);
+            if (currentContextValue) {
+                listenerCallback(currentContextValue);
+            }
+        });
+    }
+    broadcastMessageOnChannel(channel, payload, type) {
+        payload = stripOutBigInt(payload);
+        const context = {
+            type,
+            id: payload,
+        };
+        channel.broadcast(context);
+    }
+    getAndUpdateCurrentChannel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const channel = yield getCurrentChannel();
+                if (channel) {
+                    logger.debug(`fdc3 getCurrentChannel '${channel.id}'`);
+                    this._currentChannel = channel;
+                    this._currentChannel$.next(channel);
+                }
+            }
+            catch (err) {
+                logger.error('fdc3 getCurrentChannel error', err);
+            }
+        });
+    }
+    handleInteropChannelChanges() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isInteropFdc3()) {
+                // Listen to changes from the io channel selector.
+                // This can be done on the interop container window which is outside this app scope
+                // Any changes made there will be emitted here and keep channel state in sync
+                (_b = (_a = window.io) === null || _a === void 0 ? void 0 : _a.channels) === null || _b === void 0 ? void 0 : _b.onChanged((channelColor) => __awaiter(this, void 0, void 0, function* () {
+                    var _c, _d;
+                    if (((_d = (_c = this._currentChannel) === null || _c === void 0 ? void 0 : _c.displayMetadata) === null || _d === void 0 ? void 0 : _d.color) === channelColor) {
+                        return;
+                    }
+                    logger.debug(`fdc3 interop.io channel changed '${channelColor}'`);
+                    yield this.getAndUpdateCurrentChannel();
+                }));
+            }
+        });
+    }
 }
 __decorate([
     observable

package/dist/esm/index.js

@@ -1,3 +1,4 @@
+window.io = window.io || null;
 export * from './fdc3';
 export * from './fdc3-channel-event';
 export * from './util';

package/dist/esm/util/fdc3-context-listener.js

@@ -1,43 +1,23 @@
 import { __decorate } from "tslib";
-import { LifecycleMixin } from '@genesislcap/foundation-utils';
-import { customElement, FoundationElement } from '@genesislcap/web-core';
-import { FDC3 } from '../fdc3';
+import { customElement } from '@genesislcap/web-core';
+import { Fdc3SystemChannelListener, } from './fdc3-system-channel-listener';
 /**
- * fdc3-context-listener listen to channel context
+ * fdc3-context-listener listen to app channel context
  * @alpha
  */
-let Fdc3ContextListener = class Fdc3ContextListener extends LifecycleMixin(FoundationElement) {
+let Fdc3ContextListener = class Fdc3ContextListener extends Fdc3SystemChannelListener {
     constructor() {
         super(...arguments);
         this.config = [];
     }
-    deepClone() {
-        const copy = super.deepClone();
-        if (this.config) {
-            copy.config = this.config.map((c) => {
-                const copyConfig = Object.assign({}, c);
-                if (c.callback) {
-                    copyConfig.callback = c.callback.bind(this);
-                }
-                return copyConfig;
-            });
-        }
-        return copy;
-    }
-    connectedCallback() {
-        super.connectedCallback();
-        if (window.fdc3) {
-            this.config.forEach((c) => this.fdc3.addChannelListener(null, c.channelType, (message) => {
-                if (message.type === c.channelType) {
-                    c.callback(message);
-                }
-            }));
-        }
+    addChannelListeners() {
+        this.config.forEach((c) => this.fdc3.addChannelListener(c.channelName, c.channelType, (message) => {
+            if (message.type === c.channelType) {
+                c.callback(message);
+            }
+        }));
     }
 };
-__decorate([
-    FDC3
-], Fdc3ContextListener.prototype, "fdc3", void 0);
 Fdc3ContextListener = __decorate([
     customElement({
         name: 'fdc3-context-listener',

package/dist/esm/util/fdc3-intent-listener.js

@@ -0,0 +1,48 @@
+import { __awaiter, __decorate } from "tslib";
+import { LifecycleMixin } from '@genesislcap/foundation-utils';
+import { customElement, FoundationElement } from '@genesislcap/web-core';
+import { first } from 'rxjs';
+import { FDC3 } from '../fdc3';
+let Fdc3IntentListener = class Fdc3IntentListener extends LifecycleMixin(FoundationElement) {
+    constructor() {
+        super(...arguments);
+        this.intentConfig = [];
+    }
+    connectedCallback() {
+        super.connectedCallback();
+        this.fdc3.isReady$.pipe(first()).subscribe(() => __awaiter(this, void 0, void 0, function* () {
+            if (this.intentConfig) {
+                this.addIntentListeners(this.intentConfig);
+            }
+        }));
+    }
+    deepClone() {
+        const copy = super.deepClone();
+        if (this.intentConfig) {
+            copy.intentConfig = this.intentConfig.map((c) => {
+                const copyConfig = Object.assign({}, c);
+                if (c.callback) {
+                    copyConfig.callback = c.callback.bind(this);
+                }
+                return copyConfig;
+            });
+        }
+        return copy;
+    }
+    addIntentListeners(intentConfig) {
+        const intentListeners = intentConfig.reduce((listenerMap, intent) => {
+            listenerMap.set(intent.intent, intent.callback);
+            return listenerMap;
+        }, new Map());
+        this.fdc3.addIntentListeners(intentListeners);
+    }
+};
+__decorate([
+    FDC3
+], Fdc3IntentListener.prototype, "fdc3", void 0);
+Fdc3IntentListener = __decorate([
+    customElement({
+        name: 'fdc3-intent-listener',
+    })
+], Fdc3IntentListener);
+export { Fdc3IntentListener };