@rokt/dcui-orchestrator 0.0.2-rc.0

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

@@ -0,0 +1,2 @@
+export * from './auto-resize';
+export * from './content-window';

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

@@ -0,0 +1,2 @@
+export * from './auto-resize';
+export * from './content-window';

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

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

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

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

package/node_modules/@rokt/kit/http/error.d.ts

@@ -0,0 +1,7 @@
+export declare class RequestError {
+    headers: Record<string, any>;
+    status: number;
+    statusText: string;
+    url: string;
+    constructor(headers: Record<string, any>, status: number, statusText: string, url: string);
+}

package/node_modules/@rokt/kit/http/error.js

@@ -0,0 +1,8 @@
+export class RequestError {
+    constructor(headers, status, statusText, url) {
+        this.headers = headers;
+        this.status = status;
+        this.statusText = statusText;
+        this.url = url;
+    }
+}

package/node_modules/@rokt/kit/http/fetch-client.d.ts

@@ -0,0 +1,14 @@
+import { RequestOptions } from './interfaces';
+export declare const castHeaders: (headers: Headers) => Record<string, string>;
+export declare const castBody: <T = any>(response: Response) => Promise<T>;
+type FetchOptions = [
+    string,
+    {
+        method: string;
+        headers?: Record<string, string>;
+        body?: string;
+        keepalive?: boolean;
+    }
+];
+export declare const buildFetchOptions: (input: RequestOptions) => FetchOptions;
+export {};

package/node_modules/@rokt/kit/http/fetch-client.js

@@ -0,0 +1,43 @@
+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());
+    });
+};
+export const castHeaders = (headers) => {
+    const output = {};
+    headers.forEach((v, k) => (output[k.toLowerCase()] = v));
+    return output;
+};
+export const castBody = (response) => __awaiter(void 0, void 0, void 0, function* () {
+    const contentType = response.headers.get('Content-Type') || '';
+    let body;
+    if (contentType.includes('json')) {
+        body = yield response.json();
+    }
+    else {
+        body = (yield response.text());
+    }
+    return body;
+});
+export const buildFetchOptions = (input) => {
+    var _a;
+    const method = input.method || 'GET';
+    const contentType = (input.headers && input.headers['Content-Type']) || undefined;
+    if (!contentType && input.body && typeof input.body === 'object') {
+        input.body = JSON.stringify(input.body);
+        input.headers = Object.assign({ 'Content-Type': 'application/json' }, (input.headers || {}));
+    }
+    return [
+        input.url,
+        {
+            method,
+            headers: input.headers,
+            body: input.body,
+            keepalive: (_a = input.keepalive) !== null && _a !== void 0 ? _a : false,
+        },
+    ];
+};

package/node_modules/@rokt/kit/http/fetch.d.ts

@@ -0,0 +1,8 @@
+import { Client, RequestOptions, Response } from './interfaces';
+export declare class Fetch implements Client {
+    private window;
+    constructor(window: Window);
+    request<T = any>(input: RequestOptions): Promise<Response<T>>;
+    get<T = any>(url: string, headers?: Record<string, string>): Promise<Response<T>>;
+    post<T = any>(url: string, body?: Record<any, any>, headers?: Record<string, string>, keepalive?: boolean): Promise<Response<T>>;
+}

package/node_modules/@rokt/kit/http/fetch.js

@@ -0,0 +1,49 @@
+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 { RequestError } from './error';
+import { buildFetchOptions, castBody, castHeaders } from './fetch-client';
+import { Method } from './interfaces';
+export class Fetch {
+    constructor(window) {
+        this.window = window;
+    }
+    request(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.window.fetch(...buildFetchOptions(input));
+            const headers = castHeaders(response.headers);
+            if (response.ok === false) {
+                throw new RequestError(headers, response.status, response.statusText, response.url);
+            }
+            const body = yield castBody(response);
+            return {
+                body,
+                headers,
+                status: response.status,
+                statusText: response.statusText,
+            };
+        });
+    }
+    get(url, headers) {
+        return this.request({
+            url,
+            method: Method.GET,
+            headers,
+        });
+    }
+    post(url, body = {}, headers, keepalive) {
+        return this.request({
+            url,
+            method: Method.POST,
+            body,
+            headers,
+            keepalive,
+        });
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from './error';
+export * from './fetch';
+export * from './fetch-client';
+export * from './interfaces';

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

@@ -0,0 +1,4 @@
+export * from './error';
+export * from './fetch';
+export * from './fetch-client';
+export * from './interfaces';

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

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

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

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

package/node_modules/@rokt/kit/http/interfaces.d.ts

@@ -0,0 +1,35 @@
+export type Method = (typeof Method)[keyof typeof Method];
+export declare const Method: {
+    readonly GET: "GET";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+    readonly PATCH: "PATCH";
+    readonly DELETE: "DELETE";
+};
+export type MethodLiteral = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export type RequestOptions = {
+    url: string;
+    method: Method | MethodLiteral;
+    headers?: Record<string, string>;
+    body?: any;
+    withCredentials?: boolean;
+    timeout?: number;
+    keepalive?: boolean;
+};
+export type Response<T = any> = {
+    body: T;
+    status: number;
+    statusText: string;
+    headers: Record<any, any>;
+};
+export interface Requestor {
+    request<T = any>(input: RequestOptions): Promise<Response<T>>;
+}
+export interface Getter {
+    get<T = any>(url: string, headers?: Record<string, string>): Promise<Response<T>>;
+}
+export interface Poster {
+    post<T = any>(url: string, body?: Record<any, any>, headers?: Record<string, string>, keepalive?: boolean): Promise<Response<T>>;
+}
+export interface Client extends Requestor, Getter, Poster {
+}

package/node_modules/@rokt/kit/http/interfaces.js

@@ -0,0 +1,7 @@
+export const Method = {
+    GET: 'GET',
+    POST: 'POST',
+    PUT: 'PUT',
+    PATCH: 'PATCH',
+    DELETE: 'DELETE',
+};

package/node_modules/@rokt/kit/http/testing/data.d.ts

@@ -0,0 +1,17 @@
+export declare const URL = "https://somewhere-over-the.rainbow";
+export declare const TestBody: () => {
+    value: {
+        marco: string;
+    };
+    string: string;
+};
+export declare const XTestHeader: () => {
+    key: string;
+    value: string;
+    header: {
+        'X-Test-Header': string;
+    };
+};
+export declare const ContentTypeJSON: () => {
+    'Content-Type': string;
+};

package/node_modules/@rokt/kit/http/testing/data.js

@@ -0,0 +1,13 @@
+export const URL = 'https://somewhere-over-the.rainbow';
+export const TestBody = () => ({
+    value: { marco: 'polo' },
+    string: JSON.stringify({ marco: 'polo' }),
+});
+export const XTestHeader = () => ({
+    key: 'X-Test-Header',
+    value: 'Value',
+    header: { 'X-Test-Header': 'Value' },
+});
+export const ContentTypeJSON = () => ({
+    'Content-Type': 'application/json',
+});

package/node_modules/@rokt/kit/http/testing/index.barrel.d.ts

@@ -0,0 +1,3 @@
+export * from './data';
+export * from './mock-fetch';
+export * from './mock-getter';

package/node_modules/@rokt/kit/http/testing/index.barrel.js

@@ -0,0 +1,3 @@
+export * from './data';
+export * from './mock-fetch';
+export * from './mock-getter';

package/node_modules/@rokt/kit/http/testing/index.d.ts

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

package/node_modules/@rokt/kit/http/testing/index.js

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

package/node_modules/@rokt/kit/http/testing/mock-fetch.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="jest" />
+export declare class FetchMock {
+    headers: Record<string, string>;
+    status: number;
+    response: any;
+    spy: jest.Mock<any, any>;
+    constructor();
+    fetch: (...args: any) => any;
+    calledURL(): any;
+    calledOptions(): any;
+}

package/node_modules/@rokt/kit/http/testing/mock-fetch.js

@@ -0,0 +1,31 @@
+export class FetchMock {
+    constructor() {
+        this.headers = {};
+        this.status = 200;
+        this.spy = jest.fn();
+        this.fetch = (...args) => this.spy(...args);
+        const mockResponse = {
+            headers: {
+                get: (k) => this.headers[k],
+                forEach: (cb) => Object.entries(this.headers).forEach(([k, v]) => cb(k, v)),
+            },
+            text: () => Promise.resolve(this.response),
+            json: () => Promise.resolve(this.response),
+        };
+        Object.defineProperty(mockResponse, 'ok', {
+            get: () => {
+                if (this.status < 200 || this.status > 299) {
+                    return false;
+                }
+                return true;
+            },
+        });
+        this.spy.mockResolvedValue(mockResponse);
+    }
+    calledURL() {
+        return this.spy.mock.calls[0][0];
+    }
+    calledOptions() {
+        return this.spy.mock.calls[0][1];
+    }
+}

package/node_modules/@rokt/kit/http/testing/mock-getter.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="jest" />
+import { Getter } from '../interfaces';
+export declare class MockGetter implements Getter {
+    get: jest.Mock<any, any>;
+}

package/node_modules/@rokt/kit/http/testing/mock-getter.js

@@ -0,0 +1,5 @@
+export class MockGetter {
+    constructor() {
+        this.get = jest.fn();
+    }
+}

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

@@ -0,0 +1,19 @@
+export * from './crypto';
+export * from './element-factory';
+export * from './frame-finder';
+export * from './elements';
+export * from './http';
+export * from './objects';
+export * from './objects';
+export * from './page-transfer';
+export * from './resolvable-promise';
+export * from './resolvable-stream';
+export * from './retry';
+export * from './stdom';
+export * from './stream';
+export * from './strings';
+export * from './strings';
+export * from './time';
+export * from './typings';
+export * from './weblink';
+export * from './fn';

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

@@ -0,0 +1,19 @@
+export * from './crypto';
+export * from './element-factory';
+export * from './frame-finder';
+export * from './elements';
+export * from './http';
+export * from './objects';
+export * from './objects';
+export * from './page-transfer';
+export * from './resolvable-promise';
+export * from './resolvable-stream';
+export * from './retry';
+export * from './stdom';
+export * from './stream';
+export * from './strings';
+export * from './strings';
+export * from './time';
+export * from './typings';
+export * from './weblink';
+export * from './fn';

package/node_modules/@rokt/kit/objects/cloneDeep.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Deeply clones the given object returning a new object.
+ * Limitations:
+ *  - Poor support for constructor instances.
+ *  - Prototype chains will be flattened.
+ */
+export declare const cloneDeep: <T>(source: T) => T;

package/node_modules/@rokt/kit/objects/cloneDeep.js

@@ -0,0 +1,36 @@
+/**
+ * Deeply clones the given object returning a new object.
+ * Limitations:
+ *  - Poor support for constructor instances.
+ *  - Prototype chains will be flattened.
+ */
+export const cloneDeep = (source) => {
+    const refMap = new WeakMap();
+    const clone = (obj) => {
+        if (!obj || typeof obj !== 'object') {
+            return obj;
+        }
+        let value;
+        const res = Array.isArray(obj) ? [] : {};
+        const proto = Object.getPrototypeOf(res);
+        refMap.set(obj, res);
+        for (const k in obj) {
+            if (!proto[k]) {
+                value = obj[k];
+                if (value && typeof value === 'object') {
+                    if (refMap.get(value)) {
+                        res[k] = refMap.get(value);
+                    }
+                    else {
+                        res[k] = clone(value);
+                    }
+                }
+                else {
+                    res[k] = value;
+                }
+            }
+        }
+        return res;
+    };
+    return clone(source);
+};

package/node_modules/@rokt/kit/objects/filter.d.ts

@@ -0,0 +1 @@
+export declare const filter: <T = any>(source: Record<string, any>, predicate: (key: string, value: T) => boolean) => Record<string, T>;

package/node_modules/@rokt/kit/objects/filter.js

@@ -0,0 +1,10 @@
+export const filter = (source, predicate) => {
+    const result = {};
+    for (const key of Object.keys(source)) {
+        const value = source[key];
+        if (predicate(key, value)) {
+            result[key] = value;
+        }
+    }
+    return result;
+};

package/node_modules/@rokt/kit/objects/immutableMerge.d.ts

@@ -0,0 +1,15 @@
+type SimpleMerge = {
+    /**
+     * Deeply merge the properties of any number of objects into the a new object, which is going to be returned.
+     * Limitations:
+     *  - Only copies objects own enumerable properties
+     *  - Does not copy Symbol keyed properties from source objects
+     */
+    <TObject, TSource>(target: TObject, source: TSource): TObject & TSource;
+    <TObject, TSource1, TSource2>(target: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2;
+    <TObject, TSource1, TSource2, TSource3>(target: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3;
+    <TObject, TSource1, TSource2, TSource3, TSource4>(target: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4;
+    (...sources: Array<any>): any;
+};
+export declare const immutableMerge: SimpleMerge;
+export {};

package/node_modules/@rokt/kit/objects/immutableMerge.js

@@ -0,0 +1,41 @@
+import { isObject } from './isObject';
+import { cloneDeep } from './cloneDeep';
+function copyProperty(property) {
+    if (!isObject(property)) {
+        return property;
+    }
+    return cloneDeep(property);
+}
+function mergeArray(origin, source) {
+    const newArray = source.map((elem, index) => {
+        if (!isObject(elem)) {
+            return elem;
+        }
+        return merge(origin[index], elem);
+    });
+    for (let i = source.length; i < origin.length; i++) {
+        newArray.push(copyProperty(origin[i]));
+    }
+    return newArray;
+}
+function mergeObject(origin, source) {
+    const clone = cloneDeep(source);
+    Object.getOwnPropertyNames(origin).forEach((prop) => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error
+        clone[prop] = source[prop] ? merge(origin[prop], clone[prop]) : copyProperty(origin[prop]);
+    });
+    return clone;
+}
+function merge(origin, source) {
+    if (Array.isArray(source) && Array.isArray(origin)) {
+        return mergeArray(origin, source);
+    }
+    if (isObject(origin) && isObject(source)) {
+        return mergeObject(origin, source);
+    }
+    return copyProperty(source);
+}
+export const immutableMerge = (...sources) => {
+    return sources.reduce(merge, {});
+};

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

@@ -0,0 +1,6 @@
+export * from './keys';
+export * from './filter';
+export * from './cloneDeep';
+export * from './isSerialEqual';
+export * from './immutableMerge';
+export * from './simpleMerge';

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

@@ -0,0 +1,6 @@
+export * from './keys';
+export * from './filter';
+export * from './cloneDeep';
+export * from './isSerialEqual';
+export * from './immutableMerge';
+export * from './simpleMerge';

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

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

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

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

package/node_modules/@rokt/kit/objects/isObject.d.ts

@@ -0,0 +1 @@
+export declare function isObject(value: any): any;

package/node_modules/@rokt/kit/objects/isObject.js

@@ -0,0 +1,3 @@
+export function isObject(value) {
+    return value && typeof value === 'object';
+}

package/node_modules/@rokt/kit/objects/isSerialEqual.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Compares two objects for equality by serializing them to JSON strings.
+ * Limitations:
+ *  - Wont work for function properties, instance of equality, undefined properties, prototype chain comparison, etc.
+ */
+export declare const isSerialEqual: (objA: any, objB: any) => boolean;

package/node_modules/@rokt/kit/objects/isSerialEqual.js

@@ -0,0 +1,14 @@
+/**
+ * Compares two objects for equality by serializing them to JSON strings.
+ * Limitations:
+ *  - Wont work for function properties, instance of equality, undefined properties, prototype chain comparison, etc.
+ */
+export const isSerialEqual = (objA, objB) => {
+    if (objA === objB) {
+        return true;
+    }
+    if ((!objA && objB) || (!objB && objA)) {
+        return false;
+    }
+    return JSON.stringify(objA) === JSON.stringify(objB);
+};

package/node_modules/@rokt/kit/objects/keys.d.ts

@@ -0,0 +1,22 @@
+/**
+ * keys function provides additional type safety around Object.keys implementation.
+ *
+ * In TypeScript Object.keys does not make any assumptions about returned keys typing them simply as strings not keys of a given object.
+ * See: https://github.com/microsoft/TypeScript/pull/12253 for more details.
+ *
+ * As a result we may lose typings
+ *
+ * @example
+ * ```
+ * interface Dummy {
+ *   x: number;
+ *   y: number;
+ * }
+ *
+ * const dummyInstance = {x: 42, y: 42};
+ * const arrayOfNumbers: Array<string> = Object.keys(dummyInstance).map((key) => {
+ *   const temp: string = dummyInstance[key]; // we reassign number to string without compilation error
+ *   return temp;
+ * });
+ */
+export declare function keys<T extends object, K extends keyof T = keyof T>(o: T): Array<K>;

package/node_modules/@rokt/kit/objects/keys.js

@@ -0,0 +1,24 @@
+/**
+ * keys function provides additional type safety around Object.keys implementation.
+ *
+ * In TypeScript Object.keys does not make any assumptions about returned keys typing them simply as strings not keys of a given object.
+ * See: https://github.com/microsoft/TypeScript/pull/12253 for more details.
+ *
+ * As a result we may lose typings
+ *
+ * @example
+ * ```
+ * interface Dummy {
+ *   x: number;
+ *   y: number;
+ * }
+ *
+ * const dummyInstance = {x: 42, y: 42};
+ * const arrayOfNumbers: Array<string> = Object.keys(dummyInstance).map((key) => {
+ *   const temp: string = dummyInstance[key]; // we reassign number to string without compilation error
+ *   return temp;
+ * });
+ */
+export function keys(o) {
+    return Object.keys(o);
+}

package/node_modules/@rokt/kit/objects/simpleMerge.d.ts

@@ -0,0 +1,16 @@
+type SimpleMerge = {
+    /**
+     * Deeply merge the properties of any number of objects into the first given object.
+     * Limitations:
+     *  - Mutates the original target object and any child objects
+     *  - Only copies objects own enumerable properties
+     *  - Does not copy Symbol keyed properties from source objects
+     */
+    <TObject, TSource>(target: TObject, source: TSource): TObject & TSource;
+    <TObject, TSource1, TSource2>(target: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2;
+    <TObject, TSource1, TSource2, TSource3>(target: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3;
+    <TObject, TSource1, TSource2, TSource3, TSource4>(target: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4;
+    (target: any, ...sources: Array<any>): any;
+};
+export declare const simpleMerge: SimpleMerge;
+export {};

package/node_modules/@rokt/kit/objects/simpleMerge.js

@@ -0,0 +1,24 @@
+import { isObject } from './isObject';
+export const simpleMerge = (target, ...sources) => {
+    if (!sources || !isObject(target)) {
+        return target;
+    }
+    const copyProperty = (property, source) => {
+        var _a;
+        const descriptor = (_a = Object.getOwnPropertyDescriptor(source, property)) !== null && _a !== void 0 ? _a : {};
+        let val = descriptor.value;
+        if (descriptor.enumerable) {
+            if (isObject(source[property]) && isObject(target[property])) {
+                val = simpleMerge(target[property], source[property]);
+            }
+            target[property] = val;
+        }
+    };
+    sources.forEach((source) => {
+        if (!isObject(source)) {
+            return;
+        }
+        Object.getOwnPropertyNames(source).forEach((prop) => copyProperty(prop, source));
+    });
+    return target;
+};