@rokt/dcui-orchestrator 0.0.2-rc.0

package/node_modules/@rokt/kit/weblink/__tests__/tick.d.ts

@@ -0,0 +1,7 @@
+export declare class Ticker {
+    private tickLimit;
+    private onComplete;
+    ticks: number;
+    constructor(tickLimit: number, onComplete: () => void);
+    tick(): void;
+}

package/node_modules/@rokt/kit/weblink/__tests__/tick.js

@@ -0,0 +1,13 @@
+export class Ticker {
+    constructor(tickLimit, onComplete) {
+        this.tickLimit = tickLimit;
+        this.onComplete = onComplete;
+        this.ticks = 0;
+    }
+    tick() {
+        this.ticks++;
+        if (this.ticks === this.tickLimit) {
+            this.onComplete();
+        }
+    }
+}

package/node_modules/@rokt/kit/weblink/__tests__/window-link-mock.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="jest" />
+import { Subject } from '../../reactive';
+import { Link, MessageListener, Sender } from '../types';
+export declare class WindowLinkMock implements Link {
+    connect: jest.Mock<any, any>;
+    destroy: jest.Mock<any, any>;
+    onConnection: Subject<MessageListener<any> & Sender<any>>;
+}

package/node_modules/@rokt/kit/weblink/__tests__/window-link-mock.js

@@ -0,0 +1,8 @@
+import { Subject } from '../../reactive';
+export class WindowLinkMock {
+    constructor() {
+        this.connect = jest.fn();
+        this.destroy = jest.fn();
+        this.onConnection = new Subject();
+    }
+}

package/node_modules/@rokt/kit/weblink/connect.d.ts

@@ -0,0 +1,10 @@
+import { time } from '../time';
+import { Connection, EventListenerAdderRemover, OriginPostMessenger } from './types';
+export interface ConnectOptions {
+    target: OriginPostMessenger;
+    targetID?: number;
+    targetOrigin: string;
+    selfEventSource: EventListenerAdderRemover;
+    retryTimeout?: time.Duration;
+}
+export declare const connect: ({ target, targetID, targetOrigin, selfEventSource, retryTimeout, }: ConnectOptions) => Promise<Connection>;

package/node_modules/@rokt/kit/weblink/connect.js

@@ -0,0 +1,34 @@
+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 { fromEvent, lastValueFrom } from '../reactive';
+import { pipe, first } from '../reactive/operators';
+import { time } from '../time';
+import { Message } from './message';
+import { MessageType } from './message-type';
+import { PortConnection } from './port-connection';
+import { defaultID, } from './types';
+export const connect = ({ target, targetID = defaultID, targetOrigin = '*', selfEventSource, retryTimeout = time.second, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const eventStream = fromEvent(selfEventSource, 'message');
+    const filteredEvents = pipe(eventStream)(first((postMessageEvent) => { var _a; return ((_a = postMessageEvent.data) === null || _a === void 0 ? void 0 : _a.type) === MessageType.PORT_TRANSFER; }));
+    const onEvent = lastValueFrom(filteredEvents);
+    // eslint-disable-next-line prefer-const
+    let port2;
+    setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
+        while (port2 === undefined) {
+            target.postMessage(new Message(MessageType.READY_FOR_PORT, { ID: targetID }), targetOrigin);
+            yield time.sleep(retryTimeout);
+        }
+    }), 0);
+    const event = yield onEvent;
+    port2 = event.ports[0];
+    const connection = new PortConnection(port2);
+    port2.postMessage(new Message(MessageType.LISTENING));
+    return connection;
+});

package/node_modules/@rokt/kit/weblink/dom-types.d.ts

@@ -0,0 +1,33 @@
+export interface ChannelPort extends PostMessenger, EventListenerAdder, EventListenerRemover, Starter, Closer {
+}
+export interface Channel {
+    port1: ChannelPort;
+    port2: ChannelPort;
+}
+export type ChannelConstructor = new () => Channel;
+export interface ChannelEvent {
+    data: any;
+    source?: OriginPostMessenger;
+    ports?: Array<ChannelPort>;
+    currentTarget?: PostMessenger;
+}
+export interface EventListenerAdderRemover extends EventListenerAdder, EventListenerRemover {
+}
+export interface EventListenerAdder {
+    addEventListener(event: string, callback: any): void;
+}
+export interface EventListenerRemover {
+    removeEventListener(event: string, callback: any): void;
+}
+export interface Starter {
+    start(): void;
+}
+export interface Closer {
+    close(): void;
+}
+export interface PostMessenger {
+    postMessage(message: any, transfer?: Array<any>): void;
+}
+export interface OriginPostMessenger {
+    postMessage(message: any, targetOrigin?: string, transfer?: Array<any>): void;
+}

package/node_modules/@rokt/kit/weblink/dom-types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@rokt/kit/weblink/errors.d.ts

@@ -0,0 +1,4 @@
+export type Errors = (typeof Errors)[keyof typeof Errors];
+export declare const Errors: {
+    readonly NOT_CONNECTED: "NOT_CONNECTED";
+};

package/node_modules/@rokt/kit/weblink/errors.js

@@ -0,0 +1,3 @@
+export const Errors = {
+    NOT_CONNECTED: 'NOT_CONNECTED',
+};

package/node_modules/@rokt/kit/weblink/index.barrel.d.ts

@@ -0,0 +1,6 @@
+export * from './window-link';
+export * from './port-connection';
+export * from './message';
+export * from './message-type';
+export * from './types';
+export * from './dom-types';

package/node_modules/@rokt/kit/weblink/index.barrel.js

@@ -0,0 +1,6 @@
+export * from './window-link';
+export * from './port-connection';
+export * from './message';
+export * from './message-type';
+export * from './types';
+export * from './dom-types';

package/node_modules/@rokt/kit/weblink/index.d.ts

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

package/node_modules/@rokt/kit/weblink/index.js

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

package/node_modules/@rokt/kit/weblink/message-type.d.ts

@@ -0,0 +1,7 @@
+export type MessageType = (typeof MessageType)[keyof typeof MessageType];
+export declare const MessageType: {
+    readonly DATA: "LINK_SENDING_DATA";
+    readonly READY_FOR_PORT: "LINK_CLIENT_READY_FOR_PORT";
+    readonly PORT_TRANSFER: "LINK_HOST_PORT_TRANSFER";
+    readonly LISTENING: "LINK_LISTENING";
+};

package/node_modules/@rokt/kit/weblink/message-type.js

@@ -0,0 +1,6 @@
+export const MessageType = {
+    DATA: 'LINK_SENDING_DATA',
+    READY_FOR_PORT: 'LINK_CLIENT_READY_FOR_PORT',
+    PORT_TRANSFER: 'LINK_HOST_PORT_TRANSFER',
+    LISTENING: 'LINK_LISTENING',
+};

package/node_modules/@rokt/kit/weblink/message.d.ts

@@ -0,0 +1,6 @@
+import { MessageType } from './message-type';
+export declare class Message {
+    type: MessageType;
+    payload?: any;
+    constructor(type: MessageType, payload?: any);
+}

package/node_modules/@rokt/kit/weblink/message.js

@@ -0,0 +1,6 @@
+export class Message {
+    constructor(type, payload) {
+        this.type = type;
+        this.payload = payload;
+    }
+}

package/node_modules/@rokt/kit/weblink/port-connection.d.ts

@@ -0,0 +1,11 @@
+import { Subscriber } from '../reactive';
+import { ChannelPort, Connection } from './types';
+export declare class PortConnection implements Connection {
+    private port;
+    onMessage: Subscriber<any>;
+    onReady: Promise<void>;
+    private onEvent;
+    constructor(port: ChannelPort);
+    send(data: any): void;
+    private dispatch;
+}

package/node_modules/@rokt/kit/weblink/port-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 { fromEvent, lastValueFrom } from '../reactive';
+import { pipe, filter, first, map } from '../reactive/operators';
+import { Message } from './message';
+import { MessageType } from './message-type';
+export class PortConnection {
+    constructor(port) {
+        this.port = port;
+        this.onEvent = fromEvent(this.port, 'message');
+        const readyMessage = pipe(this.onEvent)(first((portEvent) => { var _a; return ((_a = portEvent.data) === null || _a === void 0 ? void 0 : _a.type) === MessageType.LISTENING; }));
+        this.onReady = lastValueFrom(readyMessage).then(() => {
+            /* ts-ignore */
+        });
+        this.onMessage = pipe(this.onEvent)(filter((event) => { var _a; return ((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) === MessageType.DATA; }), map((event) => event.data.payload));
+        this.port.start();
+    }
+    send(data) {
+        this.dispatch(data);
+    }
+    dispatch(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.onReady;
+            const msg = new Message(MessageType.DATA, data);
+            this.port.postMessage(msg);
+        });
+    }
+}

package/node_modules/@rokt/kit/weblink/types.d.ts

@@ -0,0 +1,31 @@
+export * from './dom-types';
+import { Subscriber } from '../reactive';
+import { OriginPostMessenger } from './dom-types';
+export declare const defaultID = 80;
+export type Linker = ConnectionListener;
+export interface ConnectionListener {
+    onConnection: Subscriber<MessageListener & Sender>;
+}
+export interface MessageListener<T = any> {
+    onMessage: Subscriber<T>;
+}
+export interface ReadyListener {
+    onReady: Promise<void>;
+}
+export interface Sender<T = any> {
+    send(data: T): void;
+}
+export interface Destroyer {
+    destroy(): void;
+}
+export interface ConnectOptions {
+    target: OriginPostMessenger;
+    targetID?: number;
+    targetOrigin?: string;
+    retryTimeout?: number;
+}
+export interface Connector {
+    connect(options: ConnectOptions): Promise<Connection>;
+}
+export type Link = ConnectionListener & Destroyer & Connector;
+export type Connection = MessageListener & Sender & ReadyListener;

package/node_modules/@rokt/kit/weblink/types.js

@@ -0,0 +1,2 @@
+export * from './dom-types';
+export const defaultID = 80;

package/node_modules/@rokt/kit/weblink/v2/connection.d.ts

@@ -0,0 +1,15 @@
+import { Observable } from '../../reactive';
+export interface IConnection {
+    onMessage: Observable<unknown>;
+    send<T = any>(data?: T): void;
+    disconnect(): void;
+}
+export declare class Connection implements IConnection {
+    private readonly _port;
+    readonly onMessage: Observable<unknown>;
+    private readonly _onMessage;
+    constructor(_port: MessagePort);
+    send<T = any>(payload?: T): void;
+    disconnect(): void;
+    private _onMessageFunc;
+}

package/node_modules/@rokt/kit/weblink/v2/connection.js

@@ -0,0 +1,18 @@
+import { Subject } from '../../reactive';
+export class Connection {
+    constructor(_port) {
+        this._port = _port;
+        this._onMessage = new Subject();
+        this._onMessageFunc = (event) => this._onMessage.next(event.data);
+        this.onMessage = this._onMessage.asObservable();
+        _port.addEventListener('message', this._onMessageFunc);
+        _port.start();
+    }
+    send(payload) {
+        this._port.postMessage(payload);
+    }
+    disconnect() {
+        this._port.removeEventListener('message', this._onMessageFunc);
+        this._port.close();
+    }
+}

package/node_modules/@rokt/kit/weblink/v2/index.d.ts

@@ -0,0 +1,2 @@
+export * from './weblink';
+export * from './connection';

package/node_modules/@rokt/kit/weblink/v2/index.js

@@ -0,0 +1,2 @@
+export * from './weblink';
+export * from './connection';

package/node_modules/@rokt/kit/weblink/v2/weblink.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from '../../reactive';
+import { Connection, IConnection } from './connection';
+export interface IWeblink {
+    onConnection: Observable<Connection>;
+    connect(target: any): IConnection;
+    destroy(): void;
+}
+export declare class Weblink implements IWeblink {
+    readonly onConnection: Observable<Connection>;
+    private readonly _onConnection;
+    private readonly _domains;
+    private readonly _windowRef;
+    constructor(domains?: Array<string>, windowRef?: any);
+    connect(target: any, origin?: string): IConnection;
+    destroy(): void;
+    private _onMessageFunc;
+}

package/node_modules/@rokt/kit/weblink/v2/weblink.js

@@ -0,0 +1,30 @@
+import { Subject } from '../../reactive';
+import { Connection } from './connection';
+const PREFIX = '[ROKT][WEBLINK]';
+export class Weblink {
+    constructor(domains = [], windowRef = window) {
+        this._onMessageFunc = (event) => {
+            if (typeof event.data !== 'string' ||
+                event.data !== PREFIX ||
+                (event.origin && ![window.location.origin, ...this._domains].includes(event.origin))) {
+                return;
+            }
+            this._onConnection.next(new Connection(event.ports[0]));
+        };
+        this._domains = domains;
+        this._windowRef = windowRef;
+        this._onConnection = new Subject();
+        this.onConnection = this._onConnection.asObservable();
+        this._windowRef.addEventListener('message', this._onMessageFunc);
+    }
+    connect(target, origin = this._windowRef.location.origin) {
+        const { port1, port2 } = new this._windowRef.MessageChannel();
+        target.postMessage(PREFIX, origin, [port2]);
+        const connection = new Connection(port1);
+        this._onConnection.next(connection);
+        return connection;
+    }
+    destroy() {
+        this._windowRef.removeEventListener('message', this._onMessageFunc);
+    }
+}

package/node_modules/@rokt/kit/weblink/window-link.d.ts

@@ -0,0 +1,27 @@
+import { Subscriber } from '../reactive';
+import { ChannelConstructor, EventListenerAdderRemover } from './dom-types';
+import { Connection, ConnectOptions, Link } from './types';
+export interface WindowLinkOptions {
+    selfEventSource: EventListenerAdderRemover;
+    channelConstructor: ChannelConstructor;
+    targetOrigin?: string;
+    ID?: number;
+}
+export declare class WindowLink implements Link {
+    private options;
+    onConnection: Subscriber<Connection>;
+    private onConnectionSubject;
+    private connections;
+    private onPostMessage;
+    constructor(options: WindowLinkOptions);
+    destroy(): void;
+    connect(options: ConnectOptions): Promise<Connection>;
+    private handshakeFilter;
+    private handshake;
+}
+export type CreateOptions = {
+    targetOrigin: string;
+    ID?: number;
+    window?: any;
+};
+export declare const create: ({ targetOrigin, ID, window }: CreateOptions) => WindowLink;

package/node_modules/@rokt/kit/weblink/window-link.js

@@ -0,0 +1,66 @@
+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 { fromEvent, Subject } from '../reactive';
+import { pipe, filter } from '../reactive/operators';
+import { strings } from '../strings';
+import { connect } from './connect';
+import { stdom } from '../stdom';
+import { Message } from './message';
+import { MessageType } from './message-type';
+import { PortConnection } from './port-connection';
+import { defaultID } from './types';
+export class WindowLink {
+    constructor(options) {
+        this.options = options;
+        this.onConnectionSubject = new Subject();
+        this.connections = {};
+        this.handshakeFilter = (event) => {
+            var _a;
+            return ((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) === MessageType.READY_FOR_PORT && event.data.payload.ID === (this.options.ID || defaultID);
+        };
+        this.handshake = (event) => __awaiter(this, void 0, void 0, function* () {
+            const connectionID = strings.random(20);
+            const channel = new this.options.channelConstructor();
+            const { port1, port2 } = channel;
+            const connection = new PortConnection(port1);
+            if (!event.source) {
+                return;
+            }
+            event.source.postMessage(new Message(MessageType.PORT_TRANSFER), this.options.targetOrigin, [port2]);
+            yield connection.onReady;
+            this.connections[connectionID] = connection;
+            this.onConnectionSubject.next(connection);
+            port1.postMessage(new Message(MessageType.LISTENING));
+        });
+        this.onConnection = this.onConnectionSubject.asObservable();
+        const chanelEvent = fromEvent(this.options.selfEventSource, 'message');
+        this.onPostMessage = pipe(chanelEvent)(filter(this.handshakeFilter)).subscribe(this.handshake);
+    }
+    destroy() {
+        this.onPostMessage.unsubscribe();
+    }
+    connect(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield connect({
+                target: options.target,
+                targetOrigin: this.options.targetOrigin || '*',
+                selfEventSource: this.options.selfEventSource,
+            });
+            this.onConnectionSubject.next(connection);
+            return connection;
+        });
+    }
+}
+export const create = ({ targetOrigin, ID = defaultID, window = stdom.getWindow() }) => new WindowLink({
+    targetOrigin,
+    ID,
+    selfEventSource: window,
+    channelConstructor: window.MessageChannel,
+});

package/node_modules/@rokt/plugin/bootstrap/bootstrap.d.ts

@@ -0,0 +1,8 @@
+import { PluginInterface } from '../interface';
+import { WindowRef } from '@rokt/kit/stdom';
+export type BootstrapOptions = {
+    targetWindow?: WindowRef;
+    pluginStartTimestampOverride?: Date;
+};
+export declare const PLUGIN_INSTANCE_KEY = "__roktPluginPromise";
+export declare const bootstrap: <T = any>({ targetWindow, ...args }?: BootstrapOptions) => Promise<PluginInterface<T>>;

package/node_modules/@rokt/plugin/bootstrap/bootstrap.js

@@ -0,0 +1,95 @@
+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 { ROKT_PLUGIN_LIBRARY, ROKT_PLUGIN_LIBRARY_WSDK_2, ROKT_PLUGIN_LIBRARY_REQUEST, ROKT_PLUGIN_KEY, StandaloneOptions, BootstrapMode, } from '../types';
+import { inferName, isUsingWebSdk } from '../fn';
+import { StandalonePlugin } from '../standalone';
+export const PLUGIN_INSTANCE_KEY = '__roktPluginPromise';
+export const bootstrap = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (_a = {}) {
+    var { targetWindow = window } = _a, args = __rest(_a, ["targetWindow"]);
+    const pluginStartTimestampOverride = new Date();
+    if (!isUsingWebSdk(targetWindow)) {
+        const plugin = new StandalonePlugin();
+        targetWindow[ROKT_PLUGIN_KEY] = plugin;
+        const silent = targetWindow.location.search.includes(`${StandaloneOptions.Verbose}=false`);
+        const manualBootstrap = targetWindow.location.search.includes(`${StandaloneOptions.BootstrapMode}=${BootstrapMode.Manual}`);
+        /* tslint:disable-next-line */
+        const output = (msg) => !silent && targetWindow.console.log(`%c[info] ${msg}`, 'color: #999');
+        /* tslint:disable-next-line */
+        const outputHr = () => output(`=================================`);
+        outputHr();
+        output('Plugin running in standalone mode');
+        outputHr();
+        output(`Access the plugin instance via window.${ROKT_PLUGIN_KEY}`);
+        output(` window.${ROKT_PLUGIN_KEY}.config.next({ ...config })`);
+        output(` window.${ROKT_PLUGIN_KEY}.context.getAlias.calls.length`);
+        output(` window.${ROKT_PLUGIN_KEY}.context.getAlias.mock.setResolveValue('my-plugin')`);
+        outputHr();
+        if (!silent) {
+            output('Plugin Standalone is verbose');
+            const url = new URL(targetWindow.location.href);
+            url.searchParams.set(StandaloneOptions.Verbose, 'false');
+            output(` ${url.toString()}`);
+            outputHr();
+        }
+        if (manualBootstrap) {
+            yield new Promise((res) => {
+                output('Bootstrap is being triggered manually');
+                output('To resolve plugin bootstrap() run:');
+                output(` window.${ROKT_PLUGIN_KEY}.debug.triggerBootstrap()`);
+                outputHr();
+                plugin.debug.triggerBootstrap = res;
+            });
+        }
+        else {
+            output('Bootstrap is being triggered automatically');
+            output(`To change to manual mode update the URL to include ?${StandaloneOptions.BootstrapMode}=${BootstrapMode.Manual}`);
+            const url = new URL(targetWindow.location.href);
+            url.searchParams.set(StandaloneOptions.BootstrapMode, BootstrapMode.Manual);
+            output(` ${url.toString()}`);
+            outputHr();
+        }
+        return plugin;
+    }
+    if (targetWindow[PLUGIN_INSTANCE_KEY]) {
+        return targetWindow[PLUGIN_INSTANCE_KEY];
+    }
+    const alias = inferName(targetWindow.location.href);
+    const pluginPromise = new Promise((res) => {
+        const onLibraryRequest = (event) => {
+            targetWindow.removeEventListener(ROKT_PLUGIN_LIBRARY, onLibraryRequest);
+            targetWindow.removeEventListener(ROKT_PLUGIN_LIBRARY_WSDK_2, onLibaryRequestV2);
+            const { PluginInstance } = event.detail;
+            res(new PluginInstance(Object.assign(Object.assign({}, args), { targetWindow,
+                alias,
+                pluginStartTimestampOverride })));
+        };
+        const onLibaryRequestV2 = (event) => {
+            targetWindow.removeEventListener(ROKT_PLUGIN_LIBRARY, onLibraryRequest);
+            targetWindow.removeEventListener(ROKT_PLUGIN_LIBRARY_WSDK_2, onLibaryRequestV2);
+            res(event.detail);
+        };
+        targetWindow.addEventListener(ROKT_PLUGIN_LIBRARY, onLibraryRequest);
+        targetWindow.addEventListener(ROKT_PLUGIN_LIBRARY_WSDK_2, onLibaryRequestV2);
+        targetWindow.dispatchEvent(new CustomEvent(ROKT_PLUGIN_LIBRARY_REQUEST));
+    });
+    targetWindow[PLUGIN_INSTANCE_KEY] = pluginPromise;
+    return pluginPromise;
+});

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

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

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

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

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

@@ -0,0 +1,2 @@
+export * from './infer-name';
+export * from './is-using-web-sdk';

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

@@ -0,0 +1,2 @@
+export * from './infer-name';
+export * from './is-using-web-sdk';

package/node_modules/@rokt/plugin/fn/infer-name.d.ts

@@ -0,0 +1 @@
+export declare const inferName: (href: string) => string;

package/node_modules/@rokt/plugin/fn/infer-name.js

@@ -0,0 +1,8 @@
+export const inferName = (href) => {
+    try {
+        return href.split('/plugins/')[1].split('/')[0];
+    }
+    catch (error) {
+        return '[no-alias]' + href;
+    }
+};

package/node_modules/@rokt/plugin/fn/is-using-web-sdk.d.ts

@@ -0,0 +1,3 @@
+export declare const isUsingWebSdk: (_window?: {
+    name: string;
+}) => boolean;

package/node_modules/@rokt/plugin/fn/is-using-web-sdk.js

@@ -0,0 +1,12 @@
+import { ParamKey, IntegrationType } from '../types';
+export const isUsingWebSdk = (_window = window) => {
+    try {
+        if (_window.name.includes(`${ParamKey.IntegrationType}=${IntegrationType.Standalone}`)) {
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        return true;
+    }
+};

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

@@ -0,0 +1,5 @@
+export * from './interface';
+export * from './fn';
+export * from './types';
+export * from './bootstrap';
+export * from './lib';

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

@@ -0,0 +1,6 @@
+export * from './interface';
+export * from './fn';
+export * from './types';
+export * from './bootstrap';
+// Will remove "./lib" after everyone is on bootstrap
+export * from './lib';

package/node_modules/@rokt/plugin/interface/attributes.d.ts

@@ -0,0 +1 @@
+export type NormalizedAttributes = Record<string, string>;

package/node_modules/@rokt/plugin/interface/attributes.js

@@ -0,0 +1 @@
+export {};