@rokt/dcui-orchestrator 0.0.2-rc.0

package/node_modules/@rokt/kit/cjs/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/cjs/weblink/window-link.js

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

package/node_modules/@rokt/kit/crypto/crypto.d.ts

@@ -0,0 +1,3 @@
+export declare function getSha256Hex(input: string): Promise<string>;
+export declare function getRandomValues(arr: Uint8Array | Uint16Array | Uint32Array): Uint8Array | Uint16Array | Uint32Array;
+export type HashFunc = (input: string) => Promise<string>;

package/node_modules/@rokt/kit/crypto/crypto.js

@@ -0,0 +1,50 @@
+/**
+ * Polyfills for browser crypto functionality
+ */
+function getCrypto() {
+    return window.crypto || window.msCrypto;
+}
+function toHex(hashBuffer) {
+    // convert buffer to byte array
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    // convert bytes to hex string
+    const hashHex = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
+    return hashHex;
+}
+function textEncode(text) {
+    if (window.TextEncoder) {
+        return new TextEncoder().encode(text);
+    }
+    // IE11
+    const utf8 = unescape(encodeURIComponent(text));
+    const result = new Uint8Array(utf8.length);
+    for (let i = 0; i < utf8.length; i++) {
+        result[i] = utf8.charCodeAt(i);
+    }
+    return result;
+}
+export function getSha256Hex(input) {
+    return new Promise((resolve, reject) => {
+        const msgUint8 = textEncode(input);
+        const hashResult = getCrypto().subtle.digest('SHA-256', msgUint8);
+        if (hashResult.then) {
+            hashResult.then((hashBuffer) => {
+                resolve(toHex(hashBuffer));
+            }, reject);
+        }
+        else {
+            // this is a IE11 implementation
+            hashResult.oncomplete = (evt) => {
+                // input digest as ArrayBuffer
+                const hashBuffer = evt.target.result;
+                resolve(toHex(hashBuffer));
+            };
+            hashResult.onerror = (evt) => {
+                reject(evt);
+            };
+        }
+    });
+}
+export function getRandomValues(arr) {
+    return getCrypto().getRandomValues(arr);
+}

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

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

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

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

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

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

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

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

package/node_modules/@rokt/kit/element-factory/element-factory.d.ts

@@ -0,0 +1,20 @@
+import * as CSS from 'csstype';
+export type DOMEventMap = Record<string, (e: Event) => void>;
+export type CSSProperties = CSS.Properties;
+export type HTMLTagName = keyof HTMLElementTagNameMap;
+export interface ElementOptions<T extends HTMLTagName> {
+    attributes?: Record<string, string>;
+    className?: string;
+    cssText?: string;
+    events?: DOMEventMap;
+    id?: string;
+    innerText?: string;
+    styles?: CSSProperties;
+    tag?: T;
+    title?: string;
+}
+export type CreateFunc = <T extends HTMLTagName = 'div'>(options?: ElementOptions<T>, ...children: Array<HTMLElement | string>) => HTMLElementTagNameMap[T];
+export declare const create: CreateFunc;
+export declare const setStyles: (element: HTMLElement, styles?: CSSProperties) => void;
+export declare const setEvents: (element: HTMLElement, events?: DOMEventMap) => void;
+export declare const setAttributes: (element: HTMLElement, events?: Record<string, string>) => void;

package/node_modules/@rokt/kit/element-factory/element-factory.js

@@ -0,0 +1,51 @@
+export const create = (options = {}, ...children) => {
+    const element = document.createElement(options.tag || 'div');
+    if (options.id) {
+        element.id = options.id;
+    }
+    if (options.className) {
+        element.classList.value = options.className;
+    }
+    if (options.cssText) {
+        element.style.cssText = options.cssText;
+    }
+    if (options.styles) {
+        setStyles(element, options.styles);
+    }
+    if (options.innerText) {
+        element.innerText = options.innerText;
+    }
+    if (options.events) {
+        setEvents(element, options.events);
+    }
+    if (options.attributes) {
+        setAttributes(element, options.attributes);
+    }
+    if (options.title) {
+        element.title = options.title;
+    }
+    for (const child of children) {
+        if (typeof child === 'string') {
+            element.appendChild(document.createTextNode(child));
+        }
+        else {
+            element.appendChild(child);
+        }
+    }
+    return element;
+};
+export const setStyles = (element, styles = {}) => {
+    for (const [style, value] of Object.entries(styles)) {
+        element.style[style] = value;
+    }
+};
+export const setEvents = (element, events = {}) => {
+    for (const [name, value] of Object.entries(events)) {
+        element[name] = value;
+    }
+};
+export const setAttributes = (element, events = {}) => {
+    for (const [name, value] of Object.entries(events)) {
+        element.setAttribute(name, value);
+    }
+};

package/node_modules/@rokt/kit/element-factory/index.barrel.d.ts

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

package/node_modules/@rokt/kit/element-factory/index.barrel.js

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

package/node_modules/@rokt/kit/element-factory/index.d.ts

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

package/node_modules/@rokt/kit/element-factory/index.js

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

package/node_modules/@rokt/kit/elements/highest-z-index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Finds the highest index in the current document.
+ * Derived from the following:
+ *  [1] https://stackoverflow.com/a/1118216/1058612
+ *  [2] https://stackoverflow.com/a/1118217/1058612
+ * @return An integer representing the value of the highest z-index.
+ */
+export declare function findHighestZIndex(): number;

package/node_modules/@rokt/kit/elements/highest-z-index.js

@@ -0,0 +1,29 @@
+function isNumeric(val) {
+    return !isNaN(parseFloat(val)) && isFinite(val);
+}
+function getNumericZIndex(val) {
+    return isNumeric(val) ? parseInt(val, 10) : 0;
+}
+/**
+ * Finds the highest index in the current document.
+ * Derived from the following:
+ *  [1] https://stackoverflow.com/a/1118216/1058612
+ *  [2] https://stackoverflow.com/a/1118217/1058612
+ * @return An integer representing the value of the highest z-index.
+ */
+export function findHighestZIndex() {
+    const queryObject = document.body.querySelectorAll('*');
+    // PLC-1337 [MaRu] For some reason, some nodes are lost (or they are no Elements)
+    //     resulting in a TypeError exception and therefore, raising a PLACEMENT_NOT_ATTACHED error.
+    // We must check for the existence and the type of each node before trying to calculate its 'z-index'.
+    return Array.from(queryObject)
+        .filter((node) => node && node.nodeType === Node.ELEMENT_NODE)
+        .reduce((highest, node) => {
+        // Get the calculated CSS z-index value.
+        const cssStyles = document.defaultView.getComputedStyle(node);
+        const cssZIndex = getNumericZIndex(cssStyles.getPropertyValue('z-index'));
+        const inlineZIndex = getNumericZIndex(node.style && node.style.zIndex);
+        // Take the highest z-index for this element, whether inline or from CSS.
+        return Math.max(highest, cssZIndex, inlineZIndex);
+    }, 0);
+}

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

@@ -0,0 +1 @@
+export * from './highest-z-index';

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

@@ -0,0 +1 @@
+export * from './highest-z-index';

package/node_modules/@rokt/kit/fn/debounce-promise.d.ts

@@ -0,0 +1,11 @@
+import { DebounceOptions } from './debounce';
+export type ReturnType<T> = T extends (...args: any) => infer R ? R : unknown;
+export type RemovePromise<T> = T extends Promise<infer R> ? RemovePromise<R> : T;
+/**
+ * Wrapper for the debounce method, which allows a promise to be returned,
+ * which resolves with the result of the function called.
+ * @param fn
+ * @param delay
+ * @param options
+ */
+export declare const debouncePromise: <T extends (...args: any) => any, Y = ReturnType<T>>(fn: T, delay?: number, options?: DebounceOptions) => (...args: Parameters<T>) => Promise<RemovePromise<Y>>;

package/node_modules/@rokt/kit/fn/debounce-promise.js

@@ -0,0 +1,35 @@
+import { debounce } from './debounce';
+import { ResolvablePromise } from '../resolvable-promise';
+/**
+ * Wrapper for the debounce method, which allows a promise to be returned,
+ * which resolves with the result of the function called.
+ * @param fn
+ * @param delay
+ * @param options
+ */
+export const debouncePromise = (fn, delay = 0, options = {
+    isImmediate: false,
+    useAnimationFrame: false,
+}) => {
+    let pendingPromise = new ResolvablePromise();
+    const debounceFn = debounce((...args) => {
+        try {
+            // here we want to just resolve the pending promise with the result of the function
+            // and allow a new promise to be created
+            pendingPromise === null || pendingPromise === void 0 ? void 0 : pendingPromise.resolve(fn(...args));
+        }
+        catch (e) {
+            pendingPromise === null || pendingPromise === void 0 ? void 0 : pendingPromise.reject(e);
+        }
+        // reset the promise instance
+        pendingPromise = new ResolvablePromise();
+    }, delay, options);
+    /**
+     * This is the wrapper function which returns
+     * any promises that are currently pending
+     */
+    return (...args) => {
+        debounceFn(...args);
+        return pendingPromise.promise;
+    };
+};

package/node_modules/@rokt/kit/fn/debounce.d.ts

@@ -0,0 +1,5 @@
+export type DebounceOptions = {
+    isImmediate?: boolean;
+    useAnimationFrame?: boolean;
+};
+export declare const debounce: <T extends (...args: any) => void>(fn: T, delay?: number, options?: DebounceOptions) => (...args: Parameters<T>) => void;

package/node_modules/@rokt/kit/fn/debounce.js

@@ -0,0 +1,32 @@
+export const debounce = (fn, delay = 0, options = {
+    isImmediate: false,
+    useAnimationFrame: false,
+}) => {
+    let timerId;
+    const useRaf = options.useAnimationFrame === true && typeof window.requestAnimationFrame === 'function';
+    function schedule(scheduledFn) {
+        if (useRaf) {
+            if (timerId) {
+                window.cancelAnimationFrame(timerId);
+            }
+            return window.requestAnimationFrame(scheduledFn);
+        }
+        if (timerId) {
+            clearTimeout(timerId);
+        }
+        return setTimeout(scheduledFn, delay);
+    }
+    return function debouncedFn(...args) {
+        const exec = () => {
+            timerId = undefined;
+            if (!options.isImmediate) {
+                fn(...args);
+            }
+        };
+        const shouldExec = options.isImmediate && !timerId;
+        timerId = schedule(exec);
+        if (shouldExec) {
+            fn(...args);
+        }
+    };
+};

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

@@ -0,0 +1,3 @@
+export * from './debounce';
+export * from './debounce-promise';
+export * from './times';

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

@@ -0,0 +1,3 @@
+export * from './debounce';
+export * from './debounce-promise';
+export * from './times';

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

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

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

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

package/node_modules/@rokt/kit/fn/times.d.ts

@@ -0,0 +1 @@
+export declare const times: <T>(iterations: number, callBack: (key: number) => T) => T[];

package/node_modules/@rokt/kit/fn/times.js

@@ -0,0 +1,10 @@
+export const times = (iterations, callBack) => {
+    if (!iterations) {
+        return [];
+    }
+    const result = new Array(iterations);
+    for (let i = 0; i < iterations; i++) {
+        result[i] = callBack(i);
+    }
+    return result;
+};

package/node_modules/@rokt/kit/frame-finder/client.d.ts

@@ -0,0 +1,10 @@
+import { EchoEvent } from './echo-event';
+type PredicateFn = (event: EchoEvent) => boolean;
+export declare class Client {
+    private window;
+    constructor(window: Window);
+    firstFrame(predicate: PredicateFn, targetOrigin: string, interval?: number, timeout?: number): Promise<Window | null>;
+    private listen;
+    private sweep;
+}
+export {};

package/node_modules/@rokt/kit/frame-finder/client.js

@@ -0,0 +1,65 @@
+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 { EchoEvent, FRAME_ECHO_MESSAGE } from './echo-event';
+export class Client {
+    constructor(window) {
+        this.window = window;
+    }
+    firstFrame(predicate, targetOrigin, interval = 250, timeout = 1000) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const onEcho = this.listen(predicate, timeout);
+            this.sweep(targetOrigin);
+            const intervalRef = setInterval(() => this.sweep(targetOrigin), interval);
+            const source = yield onEcho;
+            clearInterval(intervalRef);
+            return source;
+        });
+    }
+    listen(predicate, timeoutDuration) {
+        return new Promise((res) => {
+            // eslint-disable-next-line prefer-const
+            let timeoutRef;
+            const onEcho = (event) => {
+                var _a;
+                if (((_a = event.data) === null || _a === void 0 ? void 0 : _a.type) !== FRAME_ECHO_MESSAGE) {
+                    return;
+                }
+                if (predicate(event.data) === false) {
+                    return;
+                }
+                this.window.removeEventListener('message', onEcho);
+                clearTimeout(timeoutRef);
+                const source = event.source;
+                source.postMessage(new EchoEvent(this.window), '*', []);
+                res(source);
+            };
+            this.window.addEventListener('message', onEcho);
+            // Resolve promise with null if frame not found within timeout duration
+            timeoutRef = setTimeout(() => {
+                this.window.removeEventListener('message', onEcho);
+                res(null);
+            }, timeoutDuration);
+        });
+    }
+    sweep(targetOrigin) {
+        // tslint:disable-next-line
+        for (let i = 0; i < this.window.parent.frames.length; i++) {
+            try {
+                if (this.window === this.window.parent.frames[i]) {
+                    continue;
+                }
+                this.window.parent.frames[i].postMessage(new EchoEvent(this.window), targetOrigin);
+            }
+            catch (error) {
+                // Ignore
+            }
+        }
+    }
+}

package/node_modules/@rokt/kit/frame-finder/echo-event.d.ts

@@ -0,0 +1,9 @@
+export declare const FRAME_ECHO_MESSAGE = "ROKT_FRAME_ECHO_MESSAGE";
+export declare class EchoEvent {
+    type: string;
+    name?: string;
+    id?: string;
+    origin: string;
+    host: string;
+    constructor(window: Window);
+}

package/node_modules/@rokt/kit/frame-finder/echo-event.js

@@ -0,0 +1,10 @@
+export const FRAME_ECHO_MESSAGE = 'ROKT_FRAME_ECHO_MESSAGE';
+export class EchoEvent {
+    constructor(window) {
+        this.type = FRAME_ECHO_MESSAGE;
+        this.name = window.name;
+        this.id = window.id;
+        this.origin = window.location.origin;
+        this.host = window.location.host;
+    }
+}

package/node_modules/@rokt/kit/frame-finder/index.barrel.d.ts

@@ -0,0 +1,3 @@
+export * from './client';
+export * from './echo-event';
+export * from './responder';

package/node_modules/@rokt/kit/frame-finder/index.barrel.js

@@ -0,0 +1,3 @@
+export * from './client';
+export * from './echo-event';
+export * from './responder';

package/node_modules/@rokt/kit/frame-finder/index.d.ts

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

package/node_modules/@rokt/kit/frame-finder/index.js

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

package/node_modules/@rokt/kit/frame-finder/responder.d.ts

@@ -0,0 +1,8 @@
+import { urls } from '../urls';
+export declare class Responder {
+    private window;
+    private validatorService;
+    constructor(window: Window, validatorService: urls.Validator);
+    onEvent: (event: any) => void;
+    remove(): void;
+}

package/node_modules/@rokt/kit/frame-finder/responder.js

@@ -0,0 +1,22 @@
+import { EchoEvent, FRAME_ECHO_MESSAGE } from './echo-event';
+export class Responder {
+    constructor(window, validatorService) {
+        this.window = window;
+        this.validatorService = validatorService;
+        this.onEvent = (event) => {
+            var _a;
+            if (!this.validatorService.verify(event.origin)) {
+                return;
+            }
+            const data = event.data;
+            if ((data === null || data === void 0 ? void 0 : data.type) !== FRAME_ECHO_MESSAGE) {
+                return;
+            }
+            (_a = event.source) === null || _a === void 0 ? void 0 : _a.postMessage(new EchoEvent(this.window), event.origin);
+        };
+        this.window.addEventListener('message', this.onEvent);
+    }
+    remove() {
+        this.window.removeEventListener('message', this.onEvent);
+    }
+}

package/node_modules/@rokt/kit/frame-resizer/auto-resize.d.ts

@@ -0,0 +1,11 @@
+export interface AutoResizeOptions {
+    resizeCallback?: (options: {
+        height: number;
+        width: number;
+    }) => void;
+    onResized?: (options: {
+        height: string;
+        width: string;
+    }) => void;
+}
+export declare const autoResize: (element: HTMLIFrameElement, options?: AutoResizeOptions) => void;

package/node_modules/@rokt/kit/frame-resizer/auto-resize.js

@@ -0,0 +1,19 @@
+/**
+ * [ToGr] `import iframeResizer from 'iframe-resizer'` also pulls iframe resizer logic to handle content window
+ * which is not necessary on a parent page (one adding the iFrame)
+ */
+// @ts-expect-error iframe-resizer is not typed
+import iframeResizer from 'iframe-resizer/js/iframeResizer';
+export const autoResize = (element, options = {}) => {
+    const frameOptions = {
+        heightCalculationMethod: 'documentElementOffset',
+    };
+    // [ToGr] iFrame resizer will log errors for callback with undefined value
+    if (options.resizeCallback) {
+        frameOptions.resizedCallback = options.resizeCallback;
+    }
+    if (options.onResized) {
+        frameOptions.onResized = options.onResized;
+    }
+    iframeResizer(frameOptions, element);
+};

package/node_modules/@rokt/kit/frame-resizer/content-window.d.ts

@@ -0,0 +1 @@
+export declare function bootstrapContentWindow(_window: Window & typeof globalThis & any): void;