@rokt/dcui-orchestrator 0.0.2-rc.0

package/node_modules/@rokt/plugin/lib/debug.js

@@ -0,0 +1,36 @@
+import { Subject, ReplaySubject } from '@rokt/kit/reactive';
+import { ParamKey, IntegrationType } from '@rokt/wsdk-integration/plugin-runtime';
+export class Debug {
+    constructor(_window, identifier) {
+        this._window = _window;
+        this.identifier = identifier;
+        this.partnerMessages = new Subject();
+        this.pluginMessagesInbound = new Subject();
+        this.pluginChildIsClosing = new Subject();
+        this.pluginConfig = new ReplaySubject(1);
+        this.attributes = new ReplaySubject(1);
+        this.contextParams = new URLSearchParams(this._window.location.search);
+        this.nextResponse = {};
+        this.logger = this._window.console.log;
+        const setParam = (key, value) => this.contextParams.get(key) === null && this.contextParams.set(key, value);
+        setParam(ParamKey.InitTimestamp, new Date().getTime().toString());
+        setParam(ParamKey.LauncherInstanceId, ParamKey.LauncherInstanceId);
+        setParam(ParamKey.PluginInstanceId, ParamKey.PluginInstanceId);
+        setParam(ParamKey.ParentInstanceId, '');
+        setParam(ParamKey.SelectionInstanceId, ParamKey.SelectionInstanceId);
+        setParam(ParamKey.RoktTagId, ParamKey.RoktTagId);
+        setParam(ParamKey.Language, 'en');
+        setParam(ParamKey.Sandbox, 'false');
+        setParam(ParamKey.ChildPlugin, 'false');
+        setParam(ParamKey.IntegrationType, IntegrationType.Standalone);
+    }
+    setNextResponse(response) {
+        this.nextResponse = response;
+    }
+    send(event, req) {
+        this.logger(event, req);
+        const response = this.nextResponse;
+        this.nextResponse = {};
+        return response;
+    }
+}

package/node_modules/@rokt/plugin/lib/display.d.ts

@@ -0,0 +1,13 @@
+import { stream } from '@rokt/kit/stream';
+import { Subscriber } from '@rokt/kit/reactive';
+import { DisplayInterface, DisplaySettings, PluginConfig } from '../interface';
+export declare class Display implements DisplayInterface {
+    private connection;
+    private pluginConfig;
+    settings: Subscriber<DisplaySettings | undefined>;
+    private _settings;
+    private displaySettings;
+    constructor(connection: stream.Sender, pluginConfig: Subscriber<PluginConfig>);
+    setDisplaySettings(settings?: DisplaySettings): Promise<void>;
+    private getSettings;
+}

package/node_modules/@rokt/plugin/lib/display.js

@@ -0,0 +1,81 @@
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+import { isSerialEqual } from '@rokt/kit/objects';
+import { roktLauncher } from '@rokt/wsdk-integration/launcher';
+import { lastValueFrom } from '@rokt/kit/reactive';
+import { pipe, map, first, tap } from '@rokt/kit/reactive/operators';
+import { DisplayPreset } from '../interface';
+export class Display {
+    constructor(connection, pluginConfig) {
+        this.connection = connection;
+        this.pluginConfig = pluginConfig;
+        this._settings = pipe(this.pluginConfig)(map((config) => config === null || config === void 0 ? void 0 : config.display), tap((config) => (this.displaySettings = config)));
+        this.settings = this._settings;
+    }
+    setDisplaySettings() {
+        return __awaiter(this, arguments, void 0, function* (settings = {}) {
+            let selectedSettings = settings;
+            if (settings.preset) {
+                selectedSettings = Object.assign(Object.assign({}, settings), selectPreset(settings.preset));
+            }
+            const currentSettings = yield this.getSettings();
+            if (isSerialEqual(currentSettings, selectedSettings)) {
+                return;
+            }
+            yield this.connection.send(roktLauncher.MessageType.PUT_DISPLAY_SETTINGS, { body: selectedSettings });
+        });
+    }
+    getSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const onSettings = lastValueFrom(pipe(this._settings)(first()));
+            if (!this.displaySettings) {
+                return undefined;
+            }
+            return onSettings;
+        });
+    }
+}
+const selectPreset = (preset) => ({
+    [DisplayPreset.ATTACHED]: {
+        autoresize: true,
+        applyHighestZIndex: true,
+        replaceTargetElement: 'body',
+        outerCss: {
+            position: 'fixed',
+            bottom: '0',
+            left: '50%',
+            width: '100%',
+            maxWidth: '650px',
+            transform: 'translateX(-50%)',
+        },
+        innerCss: {
+            width: '100%',
+        },
+    },
+    [DisplayPreset.FULLSCREEN]: {
+        autoresize: false,
+        applyHighestZIndex: true,
+        replaceTargetElement: 'body',
+        css: {
+            position: 'fixed',
+            top: '0px',
+            left: '0px',
+            height: '100%',
+            width: '100%',
+        },
+    },
+    [DisplayPreset.EMBEDDED]: {
+        autoresize: true,
+        css: {
+            width: '1px',
+            minWidth: '100%',
+        },
+    },
+})[preset];

package/node_modules/@rokt/plugin/lib/error.d.ts

@@ -0,0 +1,9 @@
+import { stream } from '@rokt/kit/stream';
+import { ErrorInterface, RaiseErrorOptions } from '../interface';
+import { IPrivateContext } from './private-context';
+export declare class ErrorService implements ErrorInterface {
+    private _connection;
+    private _context;
+    constructor(_connection: stream.Sender, _context: IPrivateContext);
+    raise(options: RaiseErrorOptions): Promise<void>;
+}

package/node_modules/@rokt/plugin/lib/error.js

@@ -0,0 +1,35 @@
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { roktController } from '@rokt/wsdk-integration/controller';
+export class ErrorService {
+    constructor(_connection, _context) {
+        this._connection = _connection;
+        this._context = _context;
+    }
+    raise(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { additionalInformation, message } = options, otherOptions = __rest(options, ["additionalInformation", "message"]);
+            yield this._connection.send(roktController.MessageType.ERROR, {
+                body: Object.assign(Object.assign({ name: 'PluginError', reporter: 'PLUGIN', integration: this._context.getAlias(), message: message || 'Plugin error raised.' }, otherOptions), { additionalInformation }),
+            });
+        });
+    }
+}

package/node_modules/@rokt/plugin/lib/index.barrel.d.ts

@@ -0,0 +1,16 @@
+export * from './bootstrap-v1';
+export * from './plugin-instance';
+export * from './error';
+export * from './metrics';
+export * from './parent-interaction';
+export * from './partner-interaction';
+export * from './child-plugin';
+export * from './child-plugin-factory';
+export * from './context';
+export * from './unsafe';
+export * from './rdn';
+export * from './theme';
+export * from './display';
+export * from './is-inside-plugin-container';
+export * from './is-preload-frame';
+export * from '../interface';

package/node_modules/@rokt/plugin/lib/index.barrel.js

@@ -0,0 +1,16 @@
+export * from './bootstrap-v1';
+export * from './plugin-instance';
+export * from './error';
+export * from './metrics';
+export * from './parent-interaction';
+export * from './partner-interaction';
+export * from './child-plugin';
+export * from './child-plugin-factory';
+export * from './context';
+export * from './unsafe';
+export * from './rdn';
+export * from './theme';
+export * from './display';
+export * from './is-inside-plugin-container';
+export * from './is-preload-frame';
+export * from '../interface';

package/node_modules/@rokt/plugin/lib/index.d.ts

@@ -0,0 +1,3 @@
+import * as plugin from './index.barrel';
+export { plugin };
+export * from './index.barrel';

package/node_modules/@rokt/plugin/lib/index.js

@@ -0,0 +1,3 @@
+import * as plugin from './index.barrel';
+export { plugin };
+export * from './index.barrel';

package/node_modules/@rokt/plugin/lib/is-inside-plugin-container.d.ts

@@ -0,0 +1,8 @@
+import { isUsingWebSdk } from '../fn/is-using-web-sdk';
+export { isUsingWebSdk };
+/**
+ * @deprecated because the plugin runtime frame is an implementation detail of the Web SDK
+ */
+export declare const isInsidePluginContainer: (_window?: {
+    name: string;
+}) => boolean;

package/node_modules/@rokt/plugin/lib/is-inside-plugin-container.js

@@ -0,0 +1,6 @@
+import { isUsingWebSdk } from '../fn/is-using-web-sdk';
+export { isUsingWebSdk };
+/**
+ * @deprecated because the plugin runtime frame is an implementation detail of the Web SDK
+ */
+export const isInsidePluginContainer = isUsingWebSdk;

package/node_modules/@rokt/plugin/lib/is-preload-frame.d.ts

@@ -0,0 +1 @@
+export * from '@rokt/wsdk-integration/plugin-runtime/fn/is-preload-frame';

package/node_modules/@rokt/plugin/lib/is-preload-frame.js

@@ -0,0 +1 @@
+export * from '@rokt/wsdk-integration/plugin-runtime/fn/is-preload-frame';

package/node_modules/@rokt/plugin/lib/metrics.d.ts

@@ -0,0 +1,13 @@
+import { stream } from '@rokt/kit/stream';
+import { MetricsInterface } from '../interface';
+import { IPrivateContext } from './private-context';
+export declare class Metrics implements MetricsInterface {
+    private _connection;
+    private _context;
+    private _window;
+    constructor(_connection: stream.Sender, _context: IPrivateContext, _window: Window, startTimestamp: Date);
+    notifyInteractive(): Promise<void>;
+    log(metricName: string, duration: number): Promise<void>;
+    getFrameStart(): Promise<Date>;
+    private _raise;
+}

package/node_modules/@rokt/plugin/lib/metrics.js

@@ -0,0 +1,55 @@
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+import { roktController } from '@rokt/wsdk-integration/controller';
+import { MetricsEventType } from '@rokt/wsdk-integration/plugin';
+export class Metrics {
+    constructor(_connection, _context, _window, startTimestamp) {
+        this._connection = _connection;
+        this._context = _context;
+        this._window = _window;
+        this._raise(MetricsEventType.PLUGIN_START, {
+            timestamp: startTimestamp,
+        });
+        this._context.getRuntimeInitTime();
+    }
+    notifyInteractive() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._raise(MetricsEventType.PLUGIN_IS_INTERACTIVE);
+        });
+    }
+    log(metricName, duration) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this._connection.send(roktController.MessageType.LOG_METRIC, {
+                body: {
+                    metricName,
+                    duration,
+                    pluginAlias: this._context.getAlias(),
+                },
+            });
+        });
+    }
+    getFrameStart() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Date(this._window.performance.timing.navigationStart);
+        });
+    }
+    _raise(eventName_1) {
+        return __awaiter(this, arguments, void 0, function* (eventName, { timestamp, data } = {}) {
+            yield this._connection.send(roktController.MessageType.PUT_METRIC_EVENT, {
+                body: {
+                    type: eventName,
+                    pluginAlias: this._context.getAlias(),
+                    timestamp: timestamp ? timestamp.toISOString() : new Date().toISOString(),
+                    data: Object.assign({}, data),
+                },
+            });
+        });
+    }
+}

package/node_modules/@rokt/plugin/lib/parent-interaction.d.ts

@@ -0,0 +1,13 @@
+import { Subscriber } from '@rokt/kit/reactive';
+import { stream } from '@rokt/kit/stream';
+import { PluginToPluginRequest } from '@rokt/wsdk-integration/plugin';
+import { IPrivateContext } from './private-context';
+import { ParentInteractionInterface } from '../interface';
+export declare class ParentInteraction implements ParentInteractionInterface {
+    private connection;
+    private context;
+    private pluginMessagesInbound;
+    constructor(connection: stream.Sender, context: IPrivateContext, pluginMessagesInbound: Subscriber<PluginToPluginRequest>);
+    send<Req = any>(eventName: string, body?: Req): Promise<void>;
+    onEvent<T = any>(eventName: string): Subscriber<T>;
+}

package/node_modules/@rokt/plugin/lib/parent-interaction.js

@@ -0,0 +1,46 @@
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+import { pipe, filter, map } from '@rokt/kit/reactive/operators';
+import { roktController } from '@rokt/wsdk-integration/controller';
+import { RuntimeMessage } from './child-plugin';
+export class ParentInteraction {
+    constructor(connection, context, pluginMessagesInbound) {
+        this.connection = connection;
+        this.context = context;
+        this.pluginMessagesInbound = pluginMessagesInbound;
+    }
+    send(eventName, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parent = this.context.getParentInstanceId();
+            if (!parent) {
+                return;
+            }
+            yield this.connection.send(roktController.MessageType.PLUGIN_TO_PLUGIN_OUTBOUND, {
+                body: {
+                    to: parent,
+                    from: this.context.getPluginInstanceId(),
+                    eventName,
+                    body,
+                },
+            });
+        });
+    }
+    onEvent(eventName) {
+        const parentInteractionId = this.context.getParentInstanceId();
+        return pipe(this.pluginMessagesInbound)(filter((ev) => ev.from === parentInteractionId &&
+            Object.values(RuntimeMessage).includes(ev.eventName) === false &&
+            (ev.eventName === eventName || eventName === '*')), map((ev) => {
+            if (ev.eventName === '*') {
+                return { event: ev.eventName, body: ev.body };
+            }
+            return ev.body;
+        }));
+    }
+}

package/node_modules/@rokt/plugin/lib/partner-interaction.d.ts

@@ -0,0 +1,11 @@
+import { Subscriber } from '@rokt/kit/reactive';
+import { stream } from '@rokt/kit/stream';
+import { PartnerMessageRequest } from '@rokt/wsdk-integration/plugin';
+import { PartnerInteractionInterface } from '../interface';
+export declare class PartnerInteraction implements PartnerInteractionInterface {
+    private connection;
+    private partnerMessage;
+    constructor(connection: stream.Sender, partnerMessage: Subscriber<PartnerMessageRequest>);
+    send<Req = any>(eventName: string, body?: Req): Promise<void>;
+    onEvent<T = any>(event: string): Subscriber<T>;
+}

package/node_modules/@rokt/plugin/lib/partner-interaction.js

@@ -0,0 +1,35 @@
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+import { pipe, filter, map } from '@rokt/kit/reactive/operators';
+import { roktLauncher } from '@rokt/wsdk-integration/launcher';
+export class PartnerInteraction {
+    constructor(connection, partnerMessage) {
+        this.connection = connection;
+        this.partnerMessage = partnerMessage;
+    }
+    send(eventName, body) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.connection.send(roktLauncher.MessageType.PLUGIN_TO_PARTNER, {
+                body: {
+                    event: eventName,
+                    body,
+                },
+            });
+        });
+    }
+    onEvent(event) {
+        return pipe(this.partnerMessage)(filter((msg) => event === '*' || msg.event === event), map((msg) => {
+            if (event === '*') {
+                return { event, body: msg.body };
+            }
+            return msg.body;
+        }));
+    }
+}

package/node_modules/@rokt/plugin/lib/plugin-instance.d.ts

@@ -0,0 +1,32 @@
+import { Subscriber } from '@rokt/kit/reactive';
+import { roktController } from '@rokt/wsdk-integration/controller';
+import { ChildPluginFactoryInterface, ContextInterface, DisplayInterface, ErrorInterface, MetricsInterface, ParentInteractionInterface, PartnerInteractionInterface, PluginInterface, RDNInterface, ThemeInterface, UnsafeInterface, NormalizedAttributes } from '../interface';
+export type PluginAdapterOptions = {
+    alias?: string;
+    targetWindow?: any;
+    pluginStartTimestampOverride?: Date;
+};
+export declare class PluginInstance<T = any> implements PluginInterface<T> {
+    context: ContextInterface;
+    childPlugin: ChildPluginFactoryInterface;
+    parentInteraction: ParentInteractionInterface;
+    partnerInteraction: PartnerInteractionInterface;
+    rdn: RDNInterface;
+    metrics: MetricsInterface;
+    error: ErrorInterface;
+    display: DisplayInterface;
+    theme: ThemeInterface;
+    unsafe: UnsafeInterface;
+    config: Subscriber<T>;
+    attributes: Subscriber<NormalizedAttributes>;
+    private static directConnection;
+    private sender;
+    private partnerMessages;
+    private pluginMessagesInbound;
+    private pluginChildIsClosing;
+    private pluginConfig;
+    constructor({ targetWindow, alias, pluginStartTimestampOverride, }?: PluginAdapterOptions);
+    static setDirectConnection(directConnection: roktController.IDirectConnection | undefined): void;
+    private getDirectConnection;
+    private sendReadyToParent;
+}

package/node_modules/@rokt/plugin/lib/plugin-instance.js

@@ -0,0 +1,99 @@
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+const pluginStartTimestamp = new Date();
+import { Context } from './context';
+import { ParentInteraction } from './parent-interaction';
+import { PartnerInteraction } from './partner-interaction';
+import { RDN } from './rdn';
+import { Metrics } from './metrics';
+import { ErrorService } from './error';
+import { Unsafe } from './unsafe';
+import { Display } from './display';
+import { Theme } from './theme';
+import { PluginRuntimeConnection } from './plugin-runtime-connection';
+import { stdom } from '@rokt/kit/stdom';
+import { pipe, map } from '@rokt/kit/reactive/operators';
+import { toReplayObservable, toObservable } from './to-observable';
+import { MessageType, } from '@rokt/wsdk-integration/plugin';
+import { ChildPluginFactory } from './child-plugin-factory';
+import { roktController } from '@rokt/wsdk-integration/controller';
+import { RuntimeMessage } from './child-plugin';
+import { isUsingWebSdk } from '../fn';
+import { Debug } from './debug';
+import { PrivateContext } from './private-context';
+import withErrorReporting from './with-error-reporting';
+export class PluginInstance {
+    constructor({ targetWindow = stdom.getWindow(), alias = '[Plugin Name]', pluginStartTimestampOverride, } = {}) {
+        if (isUsingWebSdk(targetWindow) === true) {
+            const connection = new PluginRuntimeConnection(targetWindow, alias);
+            this.sender = connection;
+            const putConfig = toReplayObservable(connection, MessageType.PUT_CONFIG);
+            this.pluginConfig = pipe(putConfig)(map((e) => ({
+                config: e.placement.plugin.config || {},
+                display: e.display,
+                configurables: e.placement.placementConfigurables || {},
+                fonts: e.placement.fonts || [],
+                attributes: e.attributes || {},
+            })));
+            this.attributes = pipe(this.pluginConfig)(map((putConfigBody) => putConfigBody.attributes));
+            this.partnerMessages = toObservable(connection, MessageType.PARTNER_TO_PLUGIN);
+            this.pluginMessagesInbound = toObservable(connection, MessageType.PLUGIN_TO_PLUGIN_INBOUND);
+            this.pluginChildIsClosing = toObservable(connection, MessageType.PLUGIN_IS_CLOSING);
+        }
+        else {
+            /* tslint:disable-next-line */
+            targetWindow.console.warn('Running in standalone mode');
+            targetWindow.name = 'plugin_instance_id=nothing';
+            const debug = new Debug(targetWindow, alias);
+            this.partnerMessages = debug.partnerMessages;
+            this.pluginMessagesInbound = debug.pluginMessagesInbound;
+            this.pluginChildIsClosing = debug.pluginChildIsClosing;
+            this.pluginConfig = debug.pluginConfig;
+            this.sender = debug;
+            this.attributes = debug.attributes;
+            targetWindow.name = debug.contextParams.toString();
+            targetWindow.PLUGIN_DEBUG = debug;
+        }
+        const privateContext = new PrivateContext(targetWindow, this.sender, alias);
+        this.error = new ErrorService(this.sender, privateContext);
+        const privateContextWithErrorLogging = withErrorReporting(privateContext, this.error);
+        this.config = pipe(this.pluginConfig)(map((c) => c.config));
+        this.unsafe = new Unsafe();
+        this.theme = new Theme(this.pluginConfig);
+        this.display = new Display(this.sender, this.pluginConfig);
+        this.context = new Context(privateContextWithErrorLogging);
+        this.rdn = new RDN(this.sender, privateContextWithErrorLogging, this.error, this.getDirectConnection());
+        this.metrics = new Metrics(this.sender, privateContextWithErrorLogging, targetWindow, pluginStartTimestampOverride !== null && pluginStartTimestampOverride !== void 0 ? pluginStartTimestampOverride : pluginStartTimestamp);
+        this.partnerInteraction = new PartnerInteraction(this.sender, this.partnerMessages);
+        this.childPlugin = new ChildPluginFactory(this.sender, privateContextWithErrorLogging, this.pluginMessagesInbound, this.pluginChildIsClosing);
+        this.parentInteraction = new ParentInteraction(this.sender, privateContextWithErrorLogging, this.pluginMessagesInbound);
+        this.sendReadyToParent();
+    }
+    static setDirectConnection(directConnection) {
+        PluginInstance.directConnection = directConnection;
+    }
+    getDirectConnection() {
+        return PluginInstance.directConnection;
+    }
+    sendReadyToParent() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parent = yield this.context.getParentInstanceId();
+            if (parent) {
+                this.sender.send(roktController.MessageType.PLUGIN_TO_PLUGIN_OUTBOUND, {
+                    body: {
+                        from: yield this.context.getPluginInstanceId(),
+                        to: parent,
+                        eventName: RuntimeMessage.Ready,
+                    },
+                });
+            }
+        });
+    }
+}

package/node_modules/@rokt/plugin/lib/plugin-runtime-connection.d.ts

@@ -0,0 +1,6 @@
+import { stream } from '@rokt/kit/stream';
+export declare class PluginRuntimeConnection extends stream.AsyncEngine {
+    private _window;
+    private alias;
+    constructor(_window: Window, alias: string);
+}

package/node_modules/@rokt/plugin/lib/plugin-runtime-connection.js

@@ -0,0 +1,35 @@
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+import { stream } from '@rokt/kit/stream';
+import { streamInterceptors } from '@rokt/kit/stream/interceptors';
+import { streamMiddleware } from '@rokt/kit/stream/middleware';
+import { weblink } from '@rokt/kit/weblink';
+export class PluginRuntimeConnection extends stream.AsyncEngine {
+    constructor(_window, alias) {
+        super();
+        this._window = _window;
+        this.alias = alias;
+        const link = weblink.create({
+            targetOrigin: '*',
+            window: this._window,
+        });
+        link.onConnection.subscribe((connection) => __awaiter(this, void 0, void 0, function* () {
+            const { router, transmitter } = stream.create({
+                connection,
+                alias: this.alias,
+            });
+            router.use(stream.errorMiddleware.sendError);
+            router.use(streamMiddleware.location(this._window));
+            transmitter.addInterceptor(streamInterceptors.location(this._window));
+            this.setTransmitter(transmitter);
+            this.setRouter(router);
+        }));
+    }
+}

package/node_modules/@rokt/plugin/lib/private-context.d.ts

@@ -0,0 +1,39 @@
+import { stream } from '@rokt/kit/stream';
+export interface IPrivateContext {
+    getRuntimeInitTime(): Date;
+    getParentInstanceId(): string | undefined;
+    getAlias(): string;
+    getLauncherInstanceId(): string;
+    getRoktPageInstanceGuid(): string;
+    getPluginInstanceId(): string;
+    getRoktTagId(): string;
+    getRoktAccountId(): string;
+    getRoktSessionId(): string;
+    getLanguage(): string;
+    isSandboxed(): boolean;
+    isChildPlugin(): boolean;
+    isPlugin(): boolean;
+    close(): Promise<void>;
+}
+export declare class PrivateContext implements IPrivateContext {
+    private _window;
+    private _connection;
+    private _alias;
+    private _params;
+    constructor(_window: Window, _connection: stream.Sender, _alias: string);
+    getRoktPageInstanceGuid(): string;
+    getParentInstanceId(): string | undefined;
+    getRuntimeInitTime(): Date;
+    getAlias(): string;
+    getLauncherInstanceId(): string;
+    getPluginInstanceId(): string;
+    getRoktTagId(): string;
+    getRoktAccountId(): string;
+    getRoktSessionId(): string;
+    getLanguage(): string;
+    isSandboxed(): boolean;
+    isChildPlugin(): boolean;
+    isPlugin(): boolean;
+    close(): Promise<void>;
+    private _getParam;
+}