@rokt/dcui-orchestrator 0.0.2-rc.0

package/node_modules/@rokt/kit/cjs/reactive/operators/filter.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filter = void 0;
+const filter = (predicate) => (op) => {
+    if (predicate(op.value) === false) {
+        op.skip = true;
+    }
+    return op;
+};
+exports.filter = filter;

package/node_modules/@rokt/kit/cjs/reactive/operators/first.d.ts

@@ -0,0 +1,2 @@
+import { PredicateFunc, OperatorFunc } from './operation';
+export declare const first: <T>(predicate?: PredicateFunc<T> | undefined) => OperatorFunc<T, T>;

package/node_modules/@rokt/kit/cjs/reactive/operators/first.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.first = void 0;
+const first = (predicate) => (op) => {
+    if (!predicate) {
+        op.complete = true;
+    }
+    else if (predicate(op.value) === true) {
+        op.complete = true;
+    }
+    else {
+        op.skip = true;
+    }
+    return op;
+};
+exports.first = first;

package/node_modules/@rokt/kit/cjs/reactive/operators/index.d.ts

@@ -0,0 +1,5 @@
+export * from './pipe';
+export * from './filter';
+export * from './first';
+export * from './map';
+export * from './tap';

package/node_modules/@rokt/kit/cjs/reactive/operators/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./pipe"), exports);
+__exportStar(require("./filter"), exports);
+__exportStar(require("./first"), exports);
+__exportStar(require("./map"), exports);
+__exportStar(require("./tap"), exports);

package/node_modules/@rokt/kit/cjs/reactive/operators/map.d.ts

@@ -0,0 +1,2 @@
+import { OperatorFunc, UnaryFunc } from './operation';
+export declare const map: <T1, T2>(cb: UnaryFunc<T1, T2>) => OperatorFunc<T1, T2>;

package/node_modules/@rokt/kit/cjs/reactive/operators/map.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.map = void 0;
+const operation_1 = require("./operation");
+const map = (cb) => (op) => {
+    const value = cb(op.value);
+    return new operation_1.Operation(value);
+};
+exports.map = map;

package/node_modules/@rokt/kit/cjs/reactive/operators/operation.d.ts

@@ -0,0 +1,10 @@
+export type OperatorFunc<T1, T2> = (o: Operation<T1>) => Operation<T2> | Promise<Operation<T2>>;
+export type UnaryFunc<T1, T2> = (v: T1) => T2;
+export type CallbackFunc<T> = (v: T) => void;
+export type PredicateFunc<T = any> = (value: T) => boolean;
+export declare class Operation<T = void> {
+    value: T;
+    complete: boolean;
+    skip: boolean;
+    constructor(value: T);
+}

package/node_modules/@rokt/kit/cjs/reactive/operators/operation.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Operation = void 0;
+class Operation {
+    constructor(value) {
+        this.value = value;
+        this.complete = false;
+        this.skip = false;
+    }
+}
+exports.Operation = Operation;

package/node_modules/@rokt/kit/cjs/reactive/operators/pipe-func.d.ts

@@ -0,0 +1,16 @@
+import { Subscriber, Observable } from '../index';
+import { OperatorFunc } from './operation';
+export type UnwrapPromise<T> = T extends Promise<infer U> ? U : T extends (...args: Array<any>) => Promise<infer V> ? V : T;
+export type PipeFunc = <T0>(target: Subscriber<T0>) => {
+    <T1>(op1: OperatorFunc<T0, T1>): Observable<T1>;
+    <T1, T2>(op1: OperatorFunc<T0, T1>, op2: OperatorFunc<UnwrapPromise<T1>, T2>): Observable<T2>;
+    <T1, T2, T3>(op1: OperatorFunc<T0, T1>, op2: OperatorFunc<UnwrapPromise<T1>, T2>, op3: OperatorFunc<UnwrapPromise<T2>, T3>): Observable<T3>;
+    <T1, T2, T3, T4>(op1: OperatorFunc<T0, T1>, op2: OperatorFunc<UnwrapPromise<T1>, T2>, op3: OperatorFunc<UnwrapPromise<T2>, T3>, op4: OperatorFunc<UnwrapPromise<T3>, T4>): Observable<T4>;
+    <T1, T2, T3, T4, T5>(op1: OperatorFunc<T0, T1>, op2: OperatorFunc<UnwrapPromise<T1>, T2>, op3: OperatorFunc<UnwrapPromise<T2>, T3>, op4: OperatorFunc<UnwrapPromise<T3>, T4>, op5: OperatorFunc<UnwrapPromise<T4>, T5>): Observable<T5>;
+    <T1, T2, T3, T4, T5, T6>(op1: OperatorFunc<T0, T1>, op2: OperatorFunc<UnwrapPromise<T1>, T2>, op3: OperatorFunc<UnwrapPromise<T2>, T3>, op4: OperatorFunc<UnwrapPromise<T3>, T4>, op5: OperatorFunc<UnwrapPromise<T4>, T5>, op6: OperatorFunc<UnwrapPromise<T5>, T6>): Observable<T6>;
+    <T1, T2, T3, T4, T5, T6, T7>(op1: OperatorFunc<T0, T1>, op2: OperatorFunc<UnwrapPromise<T1>, T2>, op3: OperatorFunc<UnwrapPromise<T2>, T3>, op4: OperatorFunc<UnwrapPromise<T3>, T4>, op5: OperatorFunc<UnwrapPromise<T4>, T5>, op6: OperatorFunc<UnwrapPromise<T5>, T6>, op7: OperatorFunc<UnwrapPromise<T6>, T7>): Observable<T7>;
+    <T1, T2, T3, T4, T5, T6, T7, T8>(op1: OperatorFunc<T0, T1>, op2: OperatorFunc<UnwrapPromise<T1>, T2>, op3: OperatorFunc<UnwrapPromise<T2>, T3>, op4: OperatorFunc<UnwrapPromise<T3>, T4>, op5: OperatorFunc<UnwrapPromise<T4>, T5>, op6: OperatorFunc<UnwrapPromise<T5>, T6>, op7: OperatorFunc<UnwrapPromise<T6>, T7>, op8: OperatorFunc<UnwrapPromise<T7>, T8>): Observable<T8>;
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9>(op1: OperatorFunc<T0, T1>, op2: OperatorFunc<UnwrapPromise<T1>, T2>, op3: OperatorFunc<UnwrapPromise<T2>, T3>, op4: OperatorFunc<UnwrapPromise<T3>, T4>, op5: OperatorFunc<UnwrapPromise<T4>, T5>, op6: OperatorFunc<UnwrapPromise<T5>, T6>, op7: OperatorFunc<UnwrapPromise<T6>, T7>, op8: OperatorFunc<UnwrapPromise<T7>, T8>, op9: OperatorFunc<UnwrapPromise<T8>, T9>): Observable<T9>;
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(op1: OperatorFunc<T0, T1>, op2: OperatorFunc<UnwrapPromise<T1>, T2>, op3: OperatorFunc<UnwrapPromise<T2>, T3>, op4: OperatorFunc<UnwrapPromise<T3>, T4>, op5: OperatorFunc<UnwrapPromise<T4>, T5>, op6: OperatorFunc<UnwrapPromise<T5>, T6>, op7: OperatorFunc<UnwrapPromise<T6>, T7>, op8: OperatorFunc<UnwrapPromise<T7>, T8>, op9: OperatorFunc<UnwrapPromise<T8>, T9>, op10: OperatorFunc<UnwrapPromise<T9>, T10>): Observable<T10>;
+    (...ops: Array<OperatorFunc<any, any>>): Observable<any>;
+};

package/node_modules/@rokt/kit/cjs/reactive/operators/pipe-func.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@rokt/kit/cjs/reactive/operators/pipe.d.ts

@@ -0,0 +1,2 @@
+import { PipeFunc } from './pipe-func';
+export declare const pipe: PipeFunc;

package/node_modules/@rokt/kit/cjs/reactive/operators/pipe.js

@@ -0,0 +1,47 @@
+"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.pipe = void 0;
+const observable_1 = require("../observable");
+const operation_1 = require("./operation");
+const pipe = (target$) => (...ops) => {
+    return new observable_1.Observable((observer) => {
+        const sub = target$.subscribe((value) => __awaiter(void 0, void 0, void 0, function* () {
+            try {
+                let state = new operation_1.Operation(value);
+                for (const op of ops) {
+                    const update = op(state);
+                    if (update.then) {
+                        state = yield update;
+                    }
+                    else {
+                        state = update;
+                    }
+                    if (state.skip === true || state.complete === true) {
+                        break;
+                    }
+                }
+                if (state.skip) {
+                    return;
+                }
+                observer.next(state.value);
+                if (state.complete === true) {
+                    observer.complete();
+                }
+            }
+            catch (error) {
+                observer.error(error);
+            }
+        }), (error) => observer.error(error), () => observer.complete());
+        return () => sub.unsubscribe();
+    });
+};
+exports.pipe = pipe;

package/node_modules/@rokt/kit/cjs/reactive/operators/tap.d.ts

@@ -0,0 +1,2 @@
+import { OperatorFunc, CallbackFunc } from './operation';
+export declare const tap: <T>(cb: CallbackFunc<T>) => OperatorFunc<T, T>;

package/node_modules/@rokt/kit/cjs/reactive/operators/tap.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tap = void 0;
+const tap = (cb) => (op) => {
+    cb(op.value);
+    return op;
+};
+exports.tap = tap;

package/node_modules/@rokt/kit/cjs/reactive/replay-subject.d.ts

@@ -0,0 +1,14 @@
+import { Callback, Observer } from './observer';
+import { Subject } from './subject';
+import { Subscription } from './subscription';
+export declare class ReplaySubject<T = any> extends Subject<T> {
+    private _buffer;
+    private _bufferLength;
+    private _error;
+    constructor(bufferLength?: number);
+    subscribe(observer: Partial<Observer<T>>): Subscription;
+    subscribe(callback?: Callback<[T]>, error?: Callback<any>, complete?: Callback<[]>): Subscription;
+    next(value: T): void;
+    error(error?: any): void;
+    private _addToBuffer;
+}

package/node_modules/@rokt/kit/cjs/reactive/replay-subject.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplaySubject = void 0;
+const observer_1 = require("./observer");
+const subject_1 = require("./subject");
+class ReplaySubject extends subject_1.Subject {
+    constructor(bufferLength = -1) {
+        super();
+        this._buffer = [];
+        this._error = null;
+        this._bufferLength = bufferLength;
+    }
+    subscribe(callbackOrObserver, error, complete) {
+        const observer = (0, observer_1.normaliseToObserver)(callbackOrObserver, error, complete);
+        let noError = true;
+        this._buffer
+            .filter((value) => {
+            if (value === this._error) {
+                noError = false;
+            }
+            return noError;
+        })
+            .forEach((v) => observer.next(v));
+        if (this._error) {
+            observer.error(this._error);
+        }
+        observer.error = (observedError) => {
+            this._error = observedError;
+            error(observedError);
+        };
+        return super.subscribe(observer);
+    }
+    next(value) {
+        if (!this._error) {
+            this._addToBuffer(value);
+        }
+        super.next(value);
+    }
+    error(error) {
+        this._error = error;
+        this._addToBuffer(error);
+        super.error(error);
+    }
+    _addToBuffer(value) {
+        if (this._bufferLength !== -1 && this._buffer.length === this._bufferLength) {
+            this._buffer.shift();
+            this._buffer.push(value);
+        }
+        else {
+            this._buffer.push(value);
+        }
+    }
+}
+exports.ReplaySubject = ReplaySubject;

package/node_modules/@rokt/kit/cjs/reactive/rxjs/index.d.ts

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

package/node_modules/@rokt/kit/cjs/reactive/rxjs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./to-observable"), exports);

package/node_modules/@rokt/kit/cjs/reactive/rxjs/to-observable.d.ts

@@ -0,0 +1,3 @@
+import { Observable } from 'rxjs';
+import { Subscriber } from '../index';
+export declare const toObservable: <T>(source: Subscriber<T>) => Observable<T>;

package/node_modules/@rokt/kit/cjs/reactive/rxjs/to-observable.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toObservable = void 0;
+const rxjs_1 = require("rxjs");
+const toObservable = (source) => new rxjs_1.Observable((observer) => {
+    const sub = source.subscribe((value) => observer.next(value), (error) => observer.error(error), () => observer.complete());
+    return () => sub.unsubscribe();
+});
+exports.toObservable = toObservable;

package/node_modules/@rokt/kit/cjs/reactive/subject.d.ts

@@ -0,0 +1,11 @@
+import { Observable, Subscriber } from './observable';
+import { Observer } from './observer';
+export declare class Subject<T = void> extends Observable<T> implements Subscriber<T>, Observer<T> {
+    private _observers;
+    private _isComplete;
+    constructor();
+    next(value: T): void;
+    error(error?: any): void;
+    complete(): void;
+    asObservable(): Observable<T>;
+}

package/node_modules/@rokt/kit/cjs/reactive/subject.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subject = void 0;
+const observable_1 = require("./observable");
+class Subject extends observable_1.Observable {
+    constructor() {
+        super((observer) => {
+            if (this._isComplete) {
+                observer.complete();
+            }
+            this._observers.push(observer);
+            return () => (this._observers = this._observers.filter((c) => c !== observer));
+        });
+        this._observers = [];
+        this._isComplete = false;
+    }
+    next(value) {
+        for (const observer of this._observers)
+            observer.next(value);
+    }
+    error(error) {
+        for (const observer of this._observers)
+            observer.error(error);
+    }
+    complete() {
+        this._isComplete = true;
+        for (const observer of this._observers)
+            observer.complete();
+    }
+    asObservable() {
+        return new observable_1.Observable((observer) => {
+            const sub = this.subscribe(observer);
+            return () => sub.unsubscribe();
+        });
+    }
+}
+exports.Subject = Subject;

package/node_modules/@rokt/kit/cjs/reactive/subscription.d.ts

@@ -0,0 +1,8 @@
+export interface Unsubscriber {
+    unsubscribe(): void;
+}
+export declare class Subscription implements Unsubscriber {
+    private _subscribers;
+    add(subscriber: Unsubscriber): void;
+    unsubscribe(): void;
+}

package/node_modules/@rokt/kit/cjs/reactive/subscription.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subscription = void 0;
+class Subscription {
+    constructor() {
+        this._subscribers = [];
+    }
+    add(subscriber) {
+        this._subscribers.push(subscriber);
+    }
+    unsubscribe() {
+        this._subscribers.forEach((s) => s.unsubscribe());
+    }
+}
+exports.Subscription = Subscription;

package/node_modules/@rokt/kit/cjs/recogniser/accessor.d.ts

@@ -0,0 +1,18 @@
+import { stdom } from '../stdom';
+export type SessionRecogniser = {
+    cookie?: string;
+    localStorage?: string;
+};
+export declare const SESSION_RECOGNISER_KEY: string;
+export interface IAccessor {
+    setRecogniser(recogniser: SessionRecogniser): void;
+    getRecogniser(): SessionRecogniser;
+}
+export declare class Accessor implements IAccessor {
+    private cookieService;
+    private localStorageService;
+    private sameSite;
+    constructor(cookieService: stdom.CookieService, localStorageService: stdom.StorageGetterSetter, sameSite: stdom.SameSite);
+    setRecogniser(recogniser: SessionRecogniser): void;
+    getRecogniser(): SessionRecogniser;
+}

package/node_modules/@rokt/kit/cjs/recogniser/accessor.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Accessor = exports.SESSION_RECOGNISER_KEY = void 0;
+exports.SESSION_RECOGNISER_KEY = 'RoktRecogniser';
+class Accessor {
+    constructor(cookieService, localStorageService, sameSite) {
+        this.cookieService = cookieService;
+        this.localStorageService = localStorageService;
+        this.sameSite = sameSite;
+    }
+    setRecogniser(recogniser) {
+        if (recogniser.cookie) {
+            this.cookieService.setCookie({
+                name: exports.SESSION_RECOGNISER_KEY,
+                sameSite: this.sameSite,
+                secure: true,
+                value: recogniser.cookie,
+            });
+        }
+        if (recogniser.localStorage) {
+            this.localStorageService.setItem(exports.SESSION_RECOGNISER_KEY, recogniser.localStorage);
+        }
+    }
+    getRecogniser() {
+        const cookie = this.cookieService.getCookie(exports.SESSION_RECOGNISER_KEY);
+        const localStorage = this.localStorageService.getItem(exports.SESSION_RECOGNISER_KEY);
+        return {
+            cookie,
+            localStorage,
+        };
+    }
+}
+exports.Accessor = Accessor;

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirstPartyAccessor = void 0;
+const stdom_1 = require("../stdom");
+const accessor_1 = require("./accessor");
+class FirstPartyAccessor extends accessor_1.Accessor {
+    constructor(cookieService, localStorageService) {
+        super(cookieService, localStorageService, stdom_1.stdom.SameSite.Lax);
+    }
+}
+exports.FirstPartyAccessor = FirstPartyAccessor;

package/node_modules/@rokt/kit/cjs/recogniser/index.barrel.d.ts

@@ -0,0 +1,4 @@
+export { IAccessor } from './accessor';
+export * from './first-party-accessor';
+export * from './third-party-accessor';
+export * from './session-accessor';

package/node_modules/@rokt/kit/cjs/recogniser/index.barrel.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./first-party-accessor"), exports);
+__exportStar(require("./third-party-accessor"), exports);
+__exportStar(require("./session-accessor"), exports);

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

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

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

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recogniser = void 0;
+const recogniser = __importStar(require("./index.barrel"));
+exports.recogniser = recogniser;

package/node_modules/@rokt/kit/cjs/recogniser/session-accessor.d.ts

@@ -0,0 +1,20 @@
+import { stdom } from '../stdom';
+export interface ISessionAccessor {
+    setSessionInformationCookie(sessionInformation: string): void;
+    getSessionInformationCookie(): string;
+}
+export declare const SESSION_ID_KEY = "RoktSessionId";
+export type SessionCookie = {
+    sessionId: string;
+    isTestSession: boolean;
+    expirationTimestamp: number;
+};
+export declare class SessionAccessor implements ISessionAccessor {
+    private _tagId;
+    private _cookieService;
+    constructor(_tagId: string, _cookieService: stdom.CookieGetterSetter);
+    setSessionInformationCookie(sessionInformation: string): void;
+    getSessionInformationCookie(): string;
+    private _unpackSessionInformation;
+    private _validateSessionCookie;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionAccessor = exports.SESSION_ID_KEY = void 0;
+const stdom_1 = require("../stdom");
+exports.SESSION_ID_KEY = 'RoktSessionId';
+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: `${exports.SESSION_ID_KEY}-${this._tagId}`,
+                sameSite: stdom_1.stdom.SameSite.Strict,
+                secure: true,
+                value: sessionInformation,
+                expires: new Date(sessionCookie.expirationTimestamp),
+            }, true);
+        }
+    }
+    getSessionInformationCookie() {
+        const sessionInformation = this._cookieService.getCookie(`${exports.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;
+    }
+}
+exports.SessionAccessor = SessionAccessor;

package/node_modules/@rokt/kit/cjs/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/cjs/recogniser/testing/accessor-mock.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccessorMock = void 0;
+class AccessorMock {
+    constructor() {
+        this.setRecogniser = jest.fn();
+        this.getRecogniser = jest.fn();
+    }
+}
+exports.AccessorMock = AccessorMock;

package/node_modules/@rokt/kit/cjs/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/cjs/recogniser/third-party-accessor.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThirdPartyAccessor = void 0;
+const stdom_1 = require("../stdom");
+const accessor_1 = require("./accessor");
+class ThirdPartyAccessor extends accessor_1.Accessor {
+    constructor(cookieService, localStorageService) {
+        super(cookieService, localStorageService, stdom_1.stdom.SameSite.None);
+    }
+}
+exports.ThirdPartyAccessor = ThirdPartyAccessor;

package/node_modules/@rokt/kit/cjs/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/cjs/resolvable-promise/create.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+const resolvable_promise_1 = require("./resolvable-promise");
+const create = () => new resolvable_promise_1.ResolvablePromise();
+exports.create = create;

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

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