@rokt/dcui-orchestrator 0.0.2-rc.0

package/node_modules/@rokt/kit/cjs/page-transfer/testing/link.js

@@ -0,0 +1,23 @@
+"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.MockLink = void 0;
+class MockLink {
+    constructor(destroySpy = jest.fn()) {
+        this.destroySpy = destroySpy;
+    }
+    destroy() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.destroySpy();
+        });
+    }
+}
+exports.MockLink = MockLink;

package/node_modules/@rokt/kit/cjs/page-transfer/testing/mock-client.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="jest" />
+import { stdom } from '../../stdom';
+import { Client } from '../client';
+import { GetCookiesRequest } from '../handlers/get-cookies';
+import { GetLocalStorageRequest } from '../handlers/get-local-storage';
+import { ValueSet } from '../types';
+export declare class MockClient implements Client {
+    getCookieSpy: jest.Mock<any, any>;
+    setCookieSpy: jest.Mock<any, any>;
+    getLocalStorageSpy: jest.Mock<any, any>;
+    setLocalStorageSpy: jest.Mock<any, any>;
+    destroySpy: jest.Mock<any, any>;
+    destroy(): void;
+    getCookies(options: GetCookiesRequest): Promise<ValueSet>;
+    setCookies(cookies: Record<string, stdom.CookieDetails>): Promise<void>;
+    getLocalStorage(options: GetLocalStorageRequest): Promise<ValueSet>;
+    setLocalStorage(values: Record<string, string>): Promise<void>;
+}

package/node_modules/@rokt/kit/cjs/page-transfer/testing/mock-client.js

@@ -0,0 +1,45 @@
+"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.MockClient = void 0;
+class MockClient {
+    constructor() {
+        this.getCookieSpy = jest.fn();
+        this.setCookieSpy = jest.fn();
+        this.getLocalStorageSpy = jest.fn();
+        this.setLocalStorageSpy = jest.fn();
+        this.destroySpy = jest.fn();
+    }
+    destroy() {
+        this.destroySpy();
+    }
+    getCookies(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getCookieSpy(options);
+        });
+    }
+    setCookies(cookies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.setCookieSpy(cookies);
+        });
+    }
+    getLocalStorage(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.getLocalStorageSpy(options);
+        });
+    }
+    setLocalStorage(values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.setLocalStorageSpy(values);
+        });
+    }
+}
+exports.MockClient = MockClient;

package/node_modules/@rokt/kit/cjs/page-transfer/types.d.ts

@@ -0,0 +1,13 @@
+export type ValueSetQuery = {
+    keys: Array<string>;
+};
+export type ValueSetQuerier = (q: ValueSetQuery) => Promise<ValueSet>;
+export type EventType = (typeof EventType)[keyof typeof EventType];
+export declare const EventType: {
+    readonly GET_LOCAL_STORAGE: "GET_LOCAL_STORAGE";
+    readonly SET_LOCAL_STORAGE: "SET_LOCAL_STORAGE";
+    readonly GET_COOKIE: "GET_COOKIE";
+    readonly SET_COOKIE: "SET_COOKIE";
+};
+export type Value = string | undefined;
+export type ValueSet = Record<string, Value>;

package/node_modules/@rokt/kit/cjs/page-transfer/types.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventType = void 0;
+exports.EventType = {
+    GET_LOCAL_STORAGE: 'GET_LOCAL_STORAGE',
+    SET_LOCAL_STORAGE: 'SET_LOCAL_STORAGE',
+    GET_COOKIE: 'GET_COOKIE',
+    SET_COOKIE: 'SET_COOKIE',
+};

package/node_modules/@rokt/kit/cjs/page-transfer/window-client.d.ts

@@ -0,0 +1,19 @@
+import { stdom } from '../stdom';
+import { stream } from '../stream';
+import { weblink } from '../weblink';
+import { Client } from './client';
+import { GetCookiesRequest } from './handlers/get-cookies';
+import { GetLocalStorageRequest } from './handlers/get-local-storage';
+import { ValueSet } from './types';
+export declare class WindowClient implements Client {
+    private _conn;
+    private _transmitter;
+    private _iframe;
+    constructor(_conn: weblink.Destroyer, _transmitter: stream.ITransmitter, _iframe: HTMLIFrameElement);
+    destroy(): void;
+    getCookies(options: GetCookiesRequest): Promise<ValueSet>;
+    setCookies(cookies: Record<string, stdom.CookieDetails>): Promise<void>;
+    getLocalStorage(options: GetLocalStorageRequest): Promise<ValueSet>;
+    setLocalStorage(values: Record<string, string>): Promise<void>;
+}
+export declare const createClient: (targetAddress: string, windowRef: Window) => Promise<Client>;

package/node_modules/@rokt/kit/cjs/page-transfer/window-client.js

@@ -0,0 +1,81 @@
+"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.createClient = exports.WindowClient = void 0;
+const stream_1 = require("../stream");
+const interceptors_1 = require("../stream/interceptors");
+const weblink_1 = require("../weblink");
+const types_1 = require("./types");
+// WindowClient is to be instantiated on the page seeking to obtain values from a target address
+class WindowClient {
+    constructor(_conn, _transmitter, _iframe) {
+        this._conn = _conn;
+        this._transmitter = _transmitter;
+        this._iframe = _iframe;
+    }
+    destroy() {
+        var _a;
+        this._conn.destroy();
+        (_a = this._iframe.parentElement) === null || _a === void 0 ? void 0 : _a.removeChild(this._iframe);
+    }
+    getCookies(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this._transmitter.send(types_1.EventType.GET_COOKIE, {
+                body: options,
+            });
+            return response.body;
+        });
+    }
+    setCookies(cookies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = { values: cookies };
+            const response = yield this._transmitter.send(types_1.EventType.SET_COOKIE, { body });
+            return response.body;
+        });
+    }
+    getLocalStorage(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this._transmitter.send(types_1.EventType.GET_LOCAL_STORAGE, {
+                body: options,
+            });
+            return response.body;
+        });
+    }
+    setLocalStorage(values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const body = { values };
+            const response = yield this._transmitter.send(types_1.EventType.SET_LOCAL_STORAGE, { body });
+            return response.body;
+        });
+    }
+}
+exports.WindowClient = WindowClient;
+const createClient = (targetAddress, windowRef) => __awaiter(void 0, void 0, void 0, function* () {
+    const iframe = windowRef.document.createElement('iframe');
+    iframe.src = targetAddress;
+    iframe.style.display = 'none';
+    iframe.sandbox.add('allow-scripts');
+    iframe.sandbox.add('allow-same-origin');
+    const onload = new Promise((res) => (iframe.onload = res));
+    windowRef.document.body.appendChild(iframe);
+    yield onload;
+    const link = weblink_1.weblink.create({
+        targetOrigin: '*',
+        window: windowRef,
+    });
+    const connection = yield link.connect({
+        target: iframe.contentWindow,
+    });
+    const transmitter = new stream_1.stream.Transmitter({ connection });
+    transmitter.addInterceptor(interceptors_1.streamInterceptors.location(window));
+    return new WindowClient(link, transmitter, iframe);
+});
+exports.createClient = createClient;

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

@@ -0,0 +1,14 @@
+import { Callback, Observer } from './observer';
+import { Subject } from './subject';
+import { Subscription } from './subscription';
+export interface ValueGetter<T> {
+    getValue(): T;
+}
+export declare class BehaviorSubject<T = any> extends Subject<T> implements ValueGetter<T> {
+    private _lastValue;
+    constructor(initialValue: T);
+    subscribe(observer: Partial<Observer<T>>): Subscription;
+    subscribe(callback?: Callback<[T]>, error?: Callback<any>, complete?: Callback<[]>): Subscription;
+    next(value: T): void;
+    getValue(): T;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BehaviorSubject = void 0;
+const observer_1 = require("./observer");
+const subject_1 = require("./subject");
+class BehaviorSubject extends subject_1.Subject {
+    constructor(initialValue) {
+        super();
+        this._lastValue = initialValue;
+    }
+    subscribe(callbackOrObserver, error, complete) {
+        const observer = (0, observer_1.normaliseToObserver)(callbackOrObserver, error, complete);
+        observer.next(this._lastValue);
+        return super.subscribe(observer);
+    }
+    next(value) {
+        this._lastValue = value;
+        return super.next(value);
+    }
+    getValue() {
+        return this._lastValue;
+    }
+}
+exports.BehaviorSubject = BehaviorSubject;

package/node_modules/@rokt/kit/cjs/reactive/catch-subscriber.d.ts

@@ -0,0 +1,11 @@
+import { Subscriber } from './observable';
+import { Callback, Observer } from './observer';
+import { Unsubscriber } from './subscription';
+export declare function addCatchToSubscriber<T>(target: Subscriber<T>, handler: (err: Error) => void): Subscriber<T>;
+export declare class CatchSubscriber<T> implements Subscriber<T> {
+    private _target;
+    private _handler;
+    constructor(target: Subscriber<T>, handler: (err: Error) => void);
+    subscribe(observer: Partial<Observer<T>>): Unsubscriber;
+    subscribe(callback?: Callback<[T]>, error?: Callback<any>, complete?: Callback<[]>): Unsubscriber;
+}

package/node_modules/@rokt/kit/cjs/reactive/catch-subscriber.js

@@ -0,0 +1,41 @@
+"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.CatchSubscriber = exports.addCatchToSubscriber = void 0;
+function addCatchToSubscriber(target, handler) {
+    return new CatchSubscriber(target, handler);
+}
+exports.addCatchToSubscriber = addCatchToSubscriber;
+class CatchSubscriber {
+    constructor(target, handler) {
+        this._target = target;
+        this._handler = handler;
+    }
+    subscribe(callbackOrObserver, error, complete) {
+        const next = callbackOrObserver.next
+            ? callbackOrObserver.next.bind(callbackOrObserver)
+            : callbackOrObserver;
+        const wrappedObserver = {
+            next: (...args) => __awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield next(...args);
+                }
+                catch (err) {
+                    this._handler(err);
+                }
+            }),
+            error: callbackOrObserver.error ? callbackOrObserver.error.bind(callbackOrObserver) : error,
+            complete: callbackOrObserver.complete ? callbackOrObserver.complete.bind(callbackOrObserver) : complete,
+        };
+        return this._target.subscribe(wrappedObserver);
+    }
+}
+exports.CatchSubscriber = CatchSubscriber;

package/node_modules/@rokt/kit/cjs/reactive/combine-latest.d.ts

@@ -0,0 +1,11 @@
+import { Observable, Subscriber } from './observable';
+export type CombineLatest = {
+    (): Observable<[]>;
+    <T0>(s0: Subscriber<T0>): Observable<[T0]>;
+    <T0, T1>(s0: Subscriber<T0>, s1: Subscriber<T1>): Observable<[T0, T1]>;
+    <T0, T1, T2>(s0: Subscriber<T0>, s1: Subscriber<T1>, s2: Subscriber<T2>): Observable<[T0, T1, T2]>;
+    <T0, T1, T2, T3>(s0: Subscriber<T0>, s1: Subscriber<T1>, s2: Subscriber<T2>, s3: Subscriber<T3>): Observable<[T0, T1, T2, T3]>;
+    <T0, T1, T2, T3, T4>(s0: Subscriber<T0>, s1: Subscriber<T1>, s2: Subscriber<T2>, s3: Subscriber<T3>, s4: Subscriber<T4>): Observable<[T0, T1, T2, T3, T4]>;
+    (...sources: Array<Subscriber<any>>): Observable<Array<any>>;
+};
+export declare const combineLatest: CombineLatest;

package/node_modules/@rokt/kit/cjs/reactive/combine-latest.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineLatest = void 0;
+const observable_1 = require("./observable");
+const observer_1 = require("./observer");
+const subscription_1 = require("./subscription");
+const combineLatest = (...sources) => {
+    return new observable_1.Observable((observer) => {
+        if (!sources.length) {
+            observer.complete();
+            return observer_1.noop;
+        }
+        const subscription = new subscription_1.Subscription();
+        const set = new Array(sources.length);
+        const buffer = new Array(sources.length);
+        const next = (value) => !set.includes(undefined) && observer.next(value);
+        for (let i = 0; i < sources.length; i++) {
+            const s = sources[i].subscribe((value) => {
+                buffer[i] = value;
+                set[i] = true;
+                next(buffer);
+            });
+            subscription.add(s);
+        }
+        return () => subscription.unsubscribe();
+    });
+};
+exports.combineLatest = combineLatest;

package/node_modules/@rokt/kit/cjs/reactive/first-value-from.d.ts

@@ -0,0 +1,9 @@
+import { Subscriber } from './observable';
+export type FirstValueFromError = typeof FirstValueFromError;
+export declare const FirstValueFromError: {
+    CompletedBeforeEmit: string;
+};
+export interface FirstValueFromConfig<T> {
+    defaultValue: T;
+}
+export declare const firstValueFrom: <T>(source: Subscriber<T>, config?: FirstValueFromConfig<T> | undefined) => Promise<T>;

package/node_modules/@rokt/kit/cjs/reactive/first-value-from.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstValueFrom = exports.FirstValueFromError = void 0;
+exports.FirstValueFromError = {
+    CompletedBeforeEmit: 'CompletedBeforeEmit',
+};
+const firstValueFrom = (source, config) => {
+    let subscription;
+    const hasDefaultValue = typeof config === 'object';
+    return new Promise((resolve, reject) => {
+        subscription = source.subscribe(resolve, reject, () => {
+            if (hasDefaultValue) {
+                resolve(config.defaultValue);
+            }
+            else {
+                reject(new Error(exports.FirstValueFromError.CompletedBeforeEmit));
+            }
+        });
+    }).finally(() => subscription.unsubscribe());
+};
+exports.firstValueFrom = firstValueFrom;

package/node_modules/@rokt/kit/cjs/reactive/from-event.d.ts

@@ -0,0 +1,2 @@
+import { Subscriber } from './observable';
+export declare const fromEvent: <T = Event>(target: any, eventName: string) => Subscriber<T>;

package/node_modules/@rokt/kit/cjs/reactive/from-event.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromEvent = void 0;
+const observable_1 = require("./observable");
+const fromEvent = (target, eventName) => new observable_1.Observable((observer) => {
+    const listener = (event) => observer.next(event);
+    target.addEventListener(eventName, listener);
+    return () => target.removeEventListener(eventName, listener);
+});
+exports.fromEvent = fromEvent;

package/node_modules/@rokt/kit/cjs/reactive/from-promise.d.ts

@@ -0,0 +1,2 @@
+import { Observable } from './observable';
+export declare function fromPromise<T>(promise: PromiseLike<T>): Observable<T>;

package/node_modules/@rokt/kit/cjs/reactive/from-promise.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromPromise = void 0;
+const observable_1 = require("./observable");
+function fromPromise(promise) {
+    return new observable_1.Observable((observer) => {
+        promise.then((value) => {
+            observer.next(value);
+            observer.complete();
+        }, (err) => observer.error(err));
+    });
+}
+exports.fromPromise = fromPromise;

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

@@ -0,0 +1,14 @@
+export * from './subscription';
+export * from './observable';
+export * from './observer';
+export * from './subject';
+export * from './behavior-subject';
+export * from './replay-subject';
+export * from './first-value-from';
+export * from './last-value-from';
+export * from './from-event';
+export * from './from-promise';
+export * from './merge';
+export * from './of';
+export * from './combine-latest';
+export * from './catch-subscriber';

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

@@ -0,0 +1,30 @@
+"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("./subscription"), exports);
+__exportStar(require("./observable"), exports);
+__exportStar(require("./observer"), exports);
+__exportStar(require("./subject"), exports);
+__exportStar(require("./behavior-subject"), exports);
+__exportStar(require("./replay-subject"), exports);
+__exportStar(require("./first-value-from"), exports);
+__exportStar(require("./last-value-from"), exports);
+__exportStar(require("./from-event"), exports);
+__exportStar(require("./from-promise"), exports);
+__exportStar(require("./merge"), exports);
+__exportStar(require("./of"), exports);
+__exportStar(require("./combine-latest"), exports);
+__exportStar(require("./catch-subscriber"), exports);

package/node_modules/@rokt/kit/cjs/reactive/last-value-from.d.ts

@@ -0,0 +1,5 @@
+import { Subscriber } from './observable';
+export interface LastValueFromConfig<T> {
+    defaultValue: T;
+}
+export declare const lastValueFrom: <T>(o: Subscriber<T>, config?: LastValueFromConfig<T> | undefined) => Promise<T>;

package/node_modules/@rokt/kit/cjs/reactive/last-value-from.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lastValueFrom = void 0;
+const lastValueFrom = (o, config) => {
+    return new Promise((res, rej) => {
+        let lastValue;
+        if (typeof config === 'object') {
+            lastValue = config.defaultValue;
+        }
+        o.subscribe((value) => (lastValue = value), (error) => rej(error), () => res(lastValue));
+    });
+};
+exports.lastValueFrom = lastValueFrom;

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

@@ -0,0 +1,2 @@
+import { Subscriber, Observable, SubscriberValue } from './observable';
+export declare const merge: <T extends Subscriber<any>[]>(...sources: T) => Observable<SubscriberValue<T[number]>>;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = void 0;
+const observable_1 = require("./observable");
+const subscription_1 = require("./subscription");
+const merge = (...sources) => new observable_1.Observable((observer) => {
+    const subscription = new subscription_1.Subscription();
+    let totalComplete = 0;
+    const observe = () => [
+        (v) => observer.next(v),
+        (e) => observer.error(e),
+        () => {
+            totalComplete += 1;
+            if (totalComplete >= sources.length) {
+                observer.complete();
+            }
+        },
+    ];
+    for (const source of sources) {
+        subscription.add(source.subscribe(...observe()));
+    }
+    return () => subscription.unsubscribe();
+});
+exports.merge = merge;

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

@@ -0,0 +1,15 @@
+import { Callback, Observer } from './observer';
+import { Subscription, Unsubscriber } from './subscription';
+export type TeardownFn = void | Callback<[]>;
+export type SetupFn<T> = (observer: Observer<T>) => TeardownFn;
+export interface Subscriber<T> {
+    subscribe(observable: Partial<Observer<T>>): Unsubscriber;
+    subscribe(value?: Callback<[T]>, error?: Callback<any>, complete?: Callback<[]>): Unsubscriber;
+}
+export type SubscriberValue<T> = T extends Subscriber<infer U> ? U : T;
+export declare class Observable<T = void> implements Subscriber<T> {
+    private _setupFn;
+    constructor(setupFn: SetupFn<T>);
+    subscribe(observer: Partial<Observer<T>>): Subscription;
+    subscribe(callback?: Callback<[T]>, error?: Callback<any>, complete?: Callback<[]>): Subscription;
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Observable = void 0;
+const observer_1 = require("./observer");
+const subscription_1 = require("./subscription");
+class Observable {
+    constructor(setupFn) {
+        this._setupFn = setupFn;
+    }
+    subscribe(callbackOrObserver, error, complete) {
+        const observer = (0, observer_1.normaliseToObserver)(callbackOrObserver, error, complete);
+        let active = true;
+        // eslint-disable-next-line prefer-const
+        let teardown;
+        const internalObserver = {
+            next: (v) => {
+                /* tslint:disable-next-line */
+                // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                active && observer.next(v);
+            },
+            complete: () => {
+                if (!active)
+                    return;
+                if (teardown)
+                    teardown();
+                observer.complete();
+                active = false;
+            },
+            error: (err) => {
+                if (!active)
+                    return;
+                observer.error(err);
+                active = false;
+            },
+        };
+        /* tslint:disable-next-line */
+        teardown = this._setupFn(internalObserver);
+        /* tslint:disable-next-line */
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        active || (teardown && teardown());
+        const subscription = new subscription_1.Subscription();
+        subscription.add({
+            unsubscribe: () => {
+                /* tslint:disable-next-line */
+                // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+                teardown && teardown();
+                active = false;
+            },
+        });
+        return subscription;
+    }
+}
+exports.Observable = Observable;

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

@@ -0,0 +1,9 @@
+export declare const noop: () => void;
+export type Callback<T extends Array<any> = any> = (...args: T) => any | Promise<any>;
+export type NextFn<T> = (value: T) => void;
+export interface Observer<T> {
+    next: NextFn<T>;
+    error: (error?: any) => any;
+    complete: Callback<[]>;
+}
+export declare const normaliseToObserver: <T>(next?: Callback<[T]> | Observer<T>, error?: Callback<[T]>, complete?: Callback<[]>) => Observer<T>;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normaliseToObserver = exports.noop = void 0;
+/* tslint:disable-next-line */
+const noop = () => { };
+exports.noop = noop;
+const normaliseToObserver = (next = exports.noop, error = exports.noop, complete = exports.noop) => {
+    if (typeof next !== 'function') {
+        return next;
+    }
+    return {
+        next,
+        error,
+        complete,
+    };
+};
+exports.normaliseToObserver = normaliseToObserver;

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

@@ -0,0 +1,2 @@
+import { Observable } from './observable';
+export declare const of: <T = void>(...args: T[]) => Observable<T>;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.of = void 0;
+const observable_1 = require("./observable");
+const of = (...args) => {
+    return new observable_1.Observable((observer) => {
+        for (const arg of args) {
+            observer.next(arg);
+        }
+    });
+};
+exports.of = of;

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

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