@rokt/dcui-orchestrator 0.0.2-rc.0

package/node_modules/@rokt/kit/recogniser/session-accessor.js

@@ -0,0 +1,38 @@
+import { stdom } from '../stdom';
+export const SESSION_ID_KEY = 'RoktSessionId';
+export class SessionAccessor {
+    constructor(_tagId, _cookieService) {
+        this._tagId = _tagId;
+        this._cookieService = _cookieService;
+    }
+    setSessionInformationCookie(sessionInformation) {
+        const sessionCookie = this._unpackSessionInformation(sessionInformation);
+        if (this._validateSessionCookie(sessionCookie)) {
+            this._cookieService.setCookie({
+                name: `${SESSION_ID_KEY}-${this._tagId}`,
+                sameSite: stdom.SameSite.Strict,
+                secure: true,
+                value: sessionInformation,
+                expires: new Date(sessionCookie.expirationTimestamp),
+            }, true);
+        }
+    }
+    getSessionInformationCookie() {
+        const sessionInformation = this._cookieService.getCookie(`${SESSION_ID_KEY}-${this._tagId}`);
+        if (!sessionInformation || !this._validateSessionCookie(this._unpackSessionInformation(sessionInformation))) {
+            return '';
+        }
+        return sessionInformation;
+    }
+    _unpackSessionInformation(sessionInformation) {
+        const [sessionId, isTestSession, expirationTimestamp] = sessionInformation.split('|');
+        return {
+            sessionId,
+            isTestSession: isTestSession === 'true',
+            expirationTimestamp: Number(expirationTimestamp),
+        };
+    }
+    _validateSessionCookie(sessionCookie) {
+        return sessionCookie.sessionId !== '' && !!sessionCookie.expirationTimestamp;
+    }
+}

package/node_modules/@rokt/kit/recogniser/testing/accessor-mock.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="jest" />
+import { IAccessor } from '../accessor';
+export declare class AccessorMock implements IAccessor {
+    setRecogniser: jest.Mock<any, any>;
+    getRecogniser: jest.Mock<any, any>;
+}

package/node_modules/@rokt/kit/recogniser/testing/accessor-mock.js

@@ -0,0 +1,6 @@
+export class AccessorMock {
+    constructor() {
+        this.setRecogniser = jest.fn();
+        this.getRecogniser = jest.fn();
+    }
+}

package/node_modules/@rokt/kit/recogniser/third-party-accessor.d.ts

@@ -0,0 +1,5 @@
+import { stdom } from '../stdom';
+import { Accessor } from './accessor';
+export declare class ThirdPartyAccessor extends Accessor {
+    constructor(cookieService: stdom.CookieService, localStorageService: stdom.StorageGetterSetter);
+}

package/node_modules/@rokt/kit/recogniser/third-party-accessor.js

@@ -0,0 +1,7 @@
+import { stdom } from '../stdom';
+import { Accessor } from './accessor';
+export class ThirdPartyAccessor extends Accessor {
+    constructor(cookieService, localStorageService) {
+        super(cookieService, localStorageService, stdom.SameSite.None);
+    }
+}

package/node_modules/@rokt/kit/resolvable-promise/create.d.ts

@@ -0,0 +1,2 @@
+import { ResolvablePromise } from './resolvable-promise';
+export declare const create: <T = any>() => ResolvablePromise<T>;

package/node_modules/@rokt/kit/resolvable-promise/create.js

@@ -0,0 +1,2 @@
+import { ResolvablePromise } from './resolvable-promise';
+export const create = () => new ResolvablePromise();

package/node_modules/@rokt/kit/resolvable-promise/index.barrel.d.ts

@@ -0,0 +1,2 @@
+export * from './resolvable-promise';
+export * from './create';

package/node_modules/@rokt/kit/resolvable-promise/index.barrel.js

@@ -0,0 +1,2 @@
+export * from './resolvable-promise';
+export * from './create';

package/node_modules/@rokt/kit/resolvable-promise/index.d.ts

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

package/node_modules/@rokt/kit/resolvable-promise/index.js

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

package/node_modules/@rokt/kit/resolvable-promise/resolvable-promise.d.ts

@@ -0,0 +1,12 @@
+export declare class ResolvablePromise<T> {
+    readonly promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    private fulfilled;
+    private rejected;
+    constructor();
+    isFulfilled(): boolean;
+    isPending(): boolean;
+    isRejected(): boolean;
+    static resolve<T>(value: T): ResolvablePromise<T>;
+}

package/node_modules/@rokt/kit/resolvable-promise/resolvable-promise.js

@@ -0,0 +1,30 @@
+export class ResolvablePromise {
+    constructor() {
+        this.fulfilled = false;
+        this.rejected = false;
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve = resolve;
+            this.reject = reject;
+        }).then((value) => {
+            this.fulfilled = true;
+            return value;
+        }, (e) => {
+            this.rejected = true;
+            throw e;
+        });
+    }
+    isFulfilled() {
+        return this.fulfilled;
+    }
+    isPending() {
+        return !this.isFulfilled() && !this.isRejected();
+    }
+    isRejected() {
+        return this.rejected;
+    }
+    static resolve(value) {
+        const resolvablePromise = new ResolvablePromise();
+        resolvablePromise.resolve(value);
+        return resolvablePromise;
+    }
+}

package/node_modules/@rokt/kit/resolvable-stream/index.barrel.d.ts

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

package/node_modules/@rokt/kit/resolvable-stream/index.barrel.js

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

package/node_modules/@rokt/kit/resolvable-stream/index.d.ts

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

package/node_modules/@rokt/kit/resolvable-stream/index.js

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

package/node_modules/@rokt/kit/resolvable-stream/resolvable-stream.d.ts

@@ -0,0 +1,16 @@
+export type StreamGetterOptions = {
+    allowDefault?: boolean;
+};
+export interface IResolvableStream<PropertyType> {
+    resolve(value: PropertyType): void;
+    get(): Promise<PropertyType>;
+}
+export declare class ResolvableStream<PropertyType> implements IResolvableStream<PropertyType> {
+    private _valueStream;
+    private _hasResolved;
+    constructor(defaultValue?: PropertyType);
+    resolve(value: PropertyType): void;
+    get({ allowDefault }?: StreamGetterOptions): Promise<PropertyType>;
+    private _nextValue;
+    private _isUndefined;
+}

package/node_modules/@rokt/kit/resolvable-stream/resolvable-stream.js

@@ -0,0 +1,47 @@
+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 { ReplaySubject } from '../reactive';
+import { ResolvablePromise } from '../resolvable-promise';
+export class ResolvableStream {
+    constructor(defaultValue) {
+        this._valueStream = new ReplaySubject(1);
+        this._hasResolved = false;
+        if (!this._isUndefined(defaultValue)) {
+            this._valueStream.next(defaultValue);
+        }
+    }
+    resolve(value) {
+        if (!this._hasResolved) {
+            this._hasResolved = true;
+        }
+        this._valueStream.next(value);
+    }
+    get({ allowDefault } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._nextValue(allowDefault);
+        });
+    }
+    _nextValue(allowDefault = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const resolvable = new ResolvablePromise();
+            const subscription = this._valueStream.subscribe((latestValue) => {
+                if (allowDefault || this._hasResolved) {
+                    resolvable.resolve(latestValue);
+                }
+            });
+            const nextValue = yield resolvable.promise;
+            subscription.unsubscribe();
+            return nextValue;
+        });
+    }
+    _isUndefined(value) {
+        return value === undefined || value === null;
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './task';
+export * from './until-truthy';

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

@@ -0,0 +1,2 @@
+export * from './task';
+export * from './until-truthy';

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

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

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

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

package/node_modules/@rokt/kit/retry/task.d.ts

@@ -0,0 +1,9 @@
+import { time } from '../time';
+export type RetryFn<T> = () => T | Promise<T>;
+export type PredicateFn<T> = (value: T) => boolean;
+export type ErrorType = (typeof ErrorType)[keyof typeof ErrorType];
+export declare const ErrorType: {
+    readonly TIMEOUT: "TIMEOUT";
+};
+export declare const task: <T>(retryFn: RetryFn<T>, predicate: PredicateFn<T>, duration: number, retryInterval?: time.Duration) => Promise<T>;
+export declare function nTimes<T, E>(tryFn: () => Promise<T>, attempts?: number, delay?: number, shouldRetry?: (e?: E) => boolean): Promise<T>;

package/node_modules/@rokt/kit/retry/task.js

@@ -0,0 +1,44 @@
+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 { time } from '../time';
+export const ErrorType = {
+    TIMEOUT: 'TIMEOUT',
+};
+export const task = (retryFn, predicate, duration, retryInterval = time.millisecond * 25) => __awaiter(void 0, void 0, void 0, function* () {
+    let timeout = false;
+    const timer = setTimeout(() => (timeout = true), duration);
+    while (true) {
+        if (timeout) {
+            throw new Error(ErrorType.TIMEOUT);
+        }
+        const response = yield Promise.resolve().then(() => retryFn());
+        const isValid = predicate(response);
+        if (isValid === true) {
+            clearTimeout(timer);
+            return response;
+        }
+        yield time.sleep(retryInterval);
+    }
+});
+export function nTimes(tryFn, attempts = 3, delay = 100, shouldRetry = () => true) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const resolve = yield tryFn();
+            return resolve;
+        }
+        catch (error) {
+            if (attempts <= 1 || !shouldRetry(error)) {
+                throw error;
+            }
+        }
+        yield time.sleep(time.millisecond * delay);
+        return yield nTimes(tryFn, attempts - 1, delay);
+    });
+}

package/node_modules/@rokt/kit/retry/until-truthy.d.ts

@@ -0,0 +1,3 @@
+import { time } from '../time';
+import { RetryFn } from './task';
+export declare const untilTruthy: <T>(fn: RetryFn<T>, duration?: number, interval?: time.Duration) => Promise<T>;

package/node_modules/@rokt/kit/retry/until-truthy.js

@@ -0,0 +1,3 @@
+import { time } from '../time';
+import { task } from './task';
+export const untilTruthy = (fn, duration = time.second * 5, interval = time.millisecond * 25) => task(fn, (v) => !!v === true, duration, interval);

package/node_modules/@rokt/kit/stdom/cookie-service.d.ts

@@ -0,0 +1,32 @@
+export interface Cookie extends CookieDetails {
+    domain?: string;
+    name: string;
+}
+export type SameSite = (typeof SameSite)[keyof typeof SameSite];
+export declare const SameSite: {
+    readonly Lax: "lax";
+    readonly None: "none";
+    readonly Strict: "strict";
+};
+export type CookieDetails = {
+    value: string;
+    expires?: Date;
+    path?: string;
+    secure?: boolean;
+    sameSite?: SameSite;
+};
+export interface CookieGetter {
+    getCookie(name: string): string | undefined;
+}
+export interface CookieSetter {
+    setCookie(c: Cookie, useBaseDomain?: boolean): void;
+}
+export type CookieGetterSetter = CookieGetter & CookieSetter;
+export declare class CookieService implements CookieGetterSetter {
+    private window;
+    constructor(window: Window);
+    getCookie(name: string): string | undefined;
+    setCookie(c: Cookie, useBaseDomain?: boolean): void;
+    private getBaseDomain;
+    private serialize;
+}

package/node_modules/@rokt/kit/stdom/cookie-service.js

@@ -0,0 +1,60 @@
+export const SameSite = {
+    Lax: 'lax',
+    None: 'none',
+    Strict: 'strict',
+};
+export class CookieService {
+    constructor(window) {
+        this.window = window;
+    }
+    getCookie(name) {
+        try {
+            const match = this.window.document.cookie.match(new RegExp('(^| )' + name + '=([^;]+)'));
+            if (match) {
+                return match[2];
+            }
+        }
+        catch (e) {
+            // [ToGr] https://stackoverflow.com/questions/389456/cookie-blocked-not-saved-in-iframe-in-internet-explorer
+        }
+        return undefined;
+    }
+    setCookie(c, useBaseDomain = false) {
+        try {
+            if (useBaseDomain) {
+                c.domain = this.getBaseDomain();
+            }
+            this.window.document.cookie = this.serialize(c);
+        }
+        catch (error) {
+            // Ignore
+        }
+    }
+    getBaseDomain() {
+        const hostname = this.window.location.hostname;
+        const parts = hostname.split('.');
+        const tld = parts.pop();
+        const domain = parts.pop();
+        return domain && tld ? `.${domain}.${tld}` : hostname;
+    }
+    serialize(cookie) {
+        const { name, path = '/', sameSite, secure, value, domain } = cookie;
+        let { expires } = cookie;
+        if (!expires) {
+            const date = new Date();
+            date.setTime(date.getTime() + 365 * 24 * 60 * 60 * 1000);
+            expires = date;
+        }
+        let str = `${name}=${value};expires=${expires.toUTCString()};path=${path}`;
+        if (domain) {
+            str += `;domain=${domain}`;
+        }
+        if (secure) {
+            str += ';secure';
+        }
+        if (sameSite) {
+            str += `;samesite=${sameSite}`;
+        }
+        return str;
+    }
+}

package/node_modules/@rokt/kit/stdom/get-window.d.ts

@@ -0,0 +1,5 @@
+export type GetWindowError = (typeof GetWindowError)[keyof typeof GetWindowError];
+export declare const GetWindowError: {
+    readonly NO_WINDOW: "NO_WINDOW";
+};
+export declare const getWindow: () => Window;

package/node_modules/@rokt/kit/stdom/get-window.js

@@ -0,0 +1,9 @@
+export const GetWindowError = {
+    NO_WINDOW: 'NO_WINDOW',
+};
+export const getWindow = () => {
+    if (typeof window === 'undefined') {
+        throw new Error(GetWindowError.NO_WINDOW);
+    }
+    return window;
+};

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

@@ -0,0 +1,9 @@
+export * from './cookie-service';
+export * from './get-window';
+export * from './load-script';
+export * from './storage-service';
+export * from './navigator';
+export * from './target-element';
+export * from './window-property';
+export * from './window-ref';
+export * from './on-body-load';

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

@@ -0,0 +1,9 @@
+export * from './cookie-service';
+export * from './get-window';
+export * from './load-script';
+export * from './storage-service';
+export * from './navigator';
+export * from './target-element';
+export * from './window-property';
+export * from './window-ref';
+export * from './on-body-load';

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

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

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

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

package/node_modules/@rokt/kit/stdom/load-script.d.ts

@@ -0,0 +1,17 @@
+type ScriptType = 'application/javascript' | 'module';
+type CrossOrigin = 'anonymous' | 'use-credentials';
+type ReferrerPolicy = 'no-referrer-when-downgrade' | 'no-referrer' | 'origin' | 'origin-when-cross-origin' | 'same-origin' | 'strict-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+export type LoadScriptOptions = {
+    src: string;
+    target?: HTMLElement;
+    type?: ScriptType;
+    async?: boolean;
+    defer?: boolean;
+    crossorigin?: CrossOrigin;
+    integrity?: string;
+    nonce?: string;
+    nomodule?: boolean;
+    referrerpolicy?: ReferrerPolicy;
+};
+export declare const loadScript: (options: LoadScriptOptions) => Promise<HTMLScriptElement>;
+export {};

package/node_modules/@rokt/kit/stdom/load-script.js

@@ -0,0 +1,36 @@
+export const loadScript = (options) => {
+    return new Promise((resolve, reject) => {
+        const tag = document.createElement('script');
+        tag.src = options.src;
+        tag.type = options.type || 'application/javascript';
+        if (options.async) {
+            tag.async = options.async;
+        }
+        if (options.defer) {
+            tag.defer = options.defer;
+        }
+        if (options.crossorigin) {
+            tag.crossOrigin = options.crossorigin;
+        }
+        if (options.integrity) {
+            tag.integrity = options.integrity;
+        }
+        if (options.nonce) {
+            tag.nonce = options.nonce;
+        }
+        if (options.nomodule) {
+            tag.noModule = options.nomodule;
+        }
+        if (options.referrerpolicy) {
+            tag.referrerPolicy = options.referrerpolicy;
+        }
+        tag.onload = () => resolve(tag);
+        tag.onerror = reject;
+        if (options.target) {
+            options.target.appendChild(tag);
+        }
+        else {
+            document.body.appendChild(tag);
+        }
+    });
+};

package/node_modules/@rokt/kit/stdom/navigator.d.ts

@@ -0,0 +1,2 @@
+export declare const getNavigator: () => Navigator;
+export declare function getUserAgent(): string;

package/node_modules/@rokt/kit/stdom/navigator.js

@@ -0,0 +1,5 @@
+import { getWindow } from './get-window';
+export const getNavigator = () => getWindow().navigator;
+export function getUserAgent() {
+    return getNavigator().userAgent;
+}

package/node_modules/@rokt/kit/stdom/on-body-load.d.ts

@@ -0,0 +1,2 @@
+import { WindowRef } from './window-ref';
+export declare const onBodyLoad: (windowRef: WindowRef) => Promise<void>;

package/node_modules/@rokt/kit/stdom/on-body-load.js

@@ -0,0 +1,23 @@
+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 onBodyLoad = (windowRef) => __awaiter(void 0, void 0, void 0, function* () {
+    yield new Promise((res) => {
+        if (windowRef.document.body) {
+            res();
+        }
+        const observer = new windowRef.MutationObserver(() => {
+            if (windowRef.document.body) {
+                observer.disconnect();
+                res();
+            }
+        });
+        observer.observe(windowRef.document.documentElement, { childList: true });
+    });
+});

package/node_modules/@rokt/kit/stdom/storage-service.d.ts

@@ -0,0 +1,23 @@
+export interface StorageGetter {
+    getItem(key: string): undefined | string;
+}
+export interface StorageSetter {
+    setItem(key: string, value: string): void;
+}
+export type StorageGetterSetter = StorageSetter & StorageGetter;
+export declare class StorageService implements StorageGetterSetter {
+    private window;
+    private _store;
+    constructor(window: Window, type?: 'session' | 'local');
+    getItem(key: string): undefined | string;
+    setItem(key: string, value: string): void;
+}
+export declare class LocalStorageService extends StorageService {
+    constructor(window: Window);
+}
+export declare class SessionStorageService extends StorageService {
+    private persistentMemoryMap;
+    constructor(window: Window);
+    getItem(key: string): undefined | string;
+    setItem(key: string, value: string): void;
+}

package/node_modules/@rokt/kit/stdom/storage-service.js

@@ -0,0 +1,66 @@
+/* tslint:disable:max-classes-per-file*/
+export class StorageService {
+    constructor(window, type = 'local') {
+        this.window = window;
+        this._store = type === 'session' ? 'sessionStorage' : 'localStorage';
+    }
+    getItem(key) {
+        try {
+            const value = this.window[this._store].getItem(key);
+            if (value === null) {
+                return undefined;
+            }
+            return value;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    setItem(key, value) {
+        try {
+            this.window[this._store].setItem(key, value);
+        }
+        catch (error) {
+            // Ignore this
+        }
+    }
+}
+/* tslint:disable:max-classes-per-file*/
+export class LocalStorageService extends StorageService {
+    constructor(window) {
+        super(window, 'local');
+    }
+}
+/* tslint:disable:max-classes-per-file*/
+export class SessionStorageService extends StorageService {
+    constructor(window) {
+        super(window, 'session');
+        this.persistentMemoryMap = new Map();
+    }
+    getItem(key) {
+        try {
+            let value = super.getItem(key);
+            if (value !== undefined) {
+                return value;
+            }
+            value = this.persistentMemoryMap.get(key);
+            if (value !== null && value !== undefined) {
+                super.setItem(key, value);
+                return value;
+            }
+            return undefined;
+        }
+        catch (error) {
+            return undefined;
+        }
+    }
+    setItem(key, value) {
+        try {
+            this.persistentMemoryMap.set(key, value);
+            super.setItem(key, value);
+        }
+        catch (error) {
+            // Ignore this
+        }
+    }
+}

package/node_modules/@rokt/kit/stdom/target-element.d.ts

@@ -0,0 +1 @@
+export declare function escapeElementSelector(elementSelector: string): string;

package/node_modules/@rokt/kit/stdom/target-element.js

@@ -0,0 +1,3 @@
+export function escapeElementSelector(elementSelector) {
+    return elementSelector ? elementSelector.replace(/([\#\.])([0-9])/gi, '$1\\3$2 ') : elementSelector;
+}

package/node_modules/@rokt/kit/stdom/testing/create-element.d.ts

@@ -0,0 +1,3 @@
+import { MockInterface } from '../../testing';
+export type MockElement<T extends Element> = MockInterface<T>;
+export declare const MockElement: new <U extends Element>() => MockInterface<U>;