@rokt/dcui-orchestrator 0.0.2-rc.0

package/node_modules/@rokt/kit/cjs/stream/testing/mock-context.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="jest" />
+import { stream } from '../index';
+export declare class MockContext<Body = any, Response = any> implements stream.Context<Body, Response> {
+    getBody: jest.Mock<any, any>;
+    getHeaders: jest.Mock<any, any>;
+    getEvent: jest.Mock<any, any>;
+    getContext: jest.Mock<any, any>;
+    setBody: (body: Body) => void;
+    setContext: jest.Mock<any, any>;
+    setResponseHeader: jest.Mock<any, any>;
+    send: jest.Mock<any, any>;
+    sendError: jest.Mock<any, any>;
+    hasSent: jest.Mock<any, any>;
+    private _body;
+}

package/node_modules/@rokt/kit/cjs/stream/testing/mock-context.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockContext = void 0;
+class MockContext {
+    constructor() {
+        this.getBody = jest.fn().mockImplementation(() => this._body);
+        this.getHeaders = jest.fn().mockReturnValue({});
+        this.getEvent = jest.fn();
+        this.getContext = jest.fn();
+        this.setBody = jest.fn().mockImplementation((body) => (this._body = body));
+        this.setContext = jest.fn();
+        this.setResponseHeader = jest.fn();
+        this.send = jest.fn();
+        this.sendError = jest.fn();
+        this.hasSent = jest.fn().mockReturnValue(false);
+        this._body = {};
+    }
+}
+exports.MockContext = MockContext;

package/node_modules/@rokt/kit/cjs/stream/testing/mock-engine.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="jest" />
+import { Engine } from '../engine';
+export declare class MockEngine implements Engine {
+    use: jest.Mock<any, any>;
+    on: jest.Mock<any, any>;
+    close: jest.Mock<any, any>;
+    addInterceptor: jest.Mock<any, any>;
+    send: jest.Mock<any, any>;
+}

package/node_modules/@rokt/kit/cjs/stream/testing/mock-engine.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockEngine = void 0;
+class MockEngine {
+    constructor() {
+        this.use = jest.fn();
+        this.on = jest.fn();
+        this.close = jest.fn();
+        this.addInterceptor = jest.fn();
+        this.send = jest.fn();
+    }
+}
+exports.MockEngine = MockEngine;

package/node_modules/@rokt/kit/cjs/stream/testing/mock-router.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+import { stream } from '../index';
+export declare class MockRouter implements stream.IRouter {
+    use: jest.Mock<any, any>;
+    on: jest.Mock<any, any>;
+    close: jest.Mock<any, any>;
+}

package/node_modules/@rokt/kit/cjs/stream/testing/mock-router.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockRouter = void 0;
+class MockRouter {
+    constructor() {
+        this.use = jest.fn();
+        this.on = jest.fn();
+        this.close = jest.fn();
+    }
+}
+exports.MockRouter = MockRouter;

package/node_modules/@rokt/kit/cjs/stream/testing/mock-sender.d.ts

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

package/node_modules/@rokt/kit/cjs/stream/testing/mock-sender.js

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

package/node_modules/@rokt/kit/cjs/stream/testing/mock-transmitter.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="jest" />
+import { stream } from '../index';
+export declare class MockTransmitter implements stream.ITransmitter {
+    addInterceptor: jest.Mock<any, any>;
+    send: jest.Mock<any, any>;
+}

package/node_modules/@rokt/kit/cjs/stream/testing/mock-transmitter.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockTransmitter = void 0;
+class MockTransmitter {
+    constructor() {
+        this.addInterceptor = jest.fn();
+        this.send = jest.fn().mockResolvedValue({ body: {} });
+    }
+}
+exports.MockTransmitter = MockTransmitter;

package/node_modules/@rokt/kit/cjs/stream/testing/ticker.d.ts

@@ -0,0 +1,10 @@
+export declare class Ticker {
+    private tickLimit;
+    private onDone?;
+    ticks: number;
+    private $done;
+    constructor(tickLimit: number, onDone?: (() => void) | undefined);
+    done(fn: () => void): this;
+    tick(): this;
+}
+export declare const ticker: (ticks: number) => Ticker;

package/node_modules/@rokt/kit/cjs/stream/testing/ticker.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ticker = exports.Ticker = void 0;
+const reactive_1 = require("../../reactive");
+class Ticker {
+    constructor(tickLimit, onDone) {
+        this.tickLimit = tickLimit;
+        this.onDone = onDone;
+        this.ticks = 0;
+        this.$done = new reactive_1.Subject();
+        if (this.onDone) {
+            this.done(this.onDone);
+        }
+    }
+    done(fn) {
+        (0, reactive_1.lastValueFrom)(this.$done).then(fn);
+        return this;
+    }
+    tick() {
+        this.ticks++;
+        if (this.ticks === this.tickLimit) {
+            this.$done.complete();
+        }
+        return this;
+    }
+}
+exports.Ticker = Ticker;
+const ticker = (ticks) => new Ticker(ticks);
+exports.ticker = ticker;

package/node_modules/@rokt/kit/cjs/stream/transmitter.d.ts

@@ -0,0 +1,36 @@
+import { time } from '../time';
+import { Context, EventSenderReceiver } from './interfaces';
+import { StreamEvent } from './stream-event';
+export declare const getTransmitterName: (ctx: Context) => string;
+type TransmitterOptions = {
+    connection: EventSenderReceiver<StreamEvent>;
+    timeoutDuration?: time.Duration;
+    alias?: string;
+    id?: string;
+};
+export declare class Transmitter implements ITransmitter {
+    private options;
+    private id;
+    private alias;
+    private connection;
+    private timeoutDuration;
+    private interceptors;
+    constructor(options: TransmitterOptions);
+    addInterceptor(interceptor: Interceptor): void;
+    send<Req = any, Res = any>(event: string, { body, headers }?: RequestContext<Req>): Promise<StreamEvent<Res>>;
+    private runInterceptors;
+    private createRequest;
+}
+export interface Sender {
+    send<Req = any, Res = any>(event: string, req?: RequestContext<Req>): Promise<StreamEvent<Res>>;
+}
+export interface ITransmitter {
+    addInterceptor(interceptor: Interceptor): void;
+    send<Req = any, Res = any>(event: string, req?: RequestContext<Req>): Promise<StreamEvent<Res>>;
+}
+export type RequestContext<T = any> = {
+    body?: T;
+    headers?: Record<string, string>;
+};
+export type Interceptor = (req: StreamEvent) => void;
+export {};

package/node_modules/@rokt/kit/cjs/stream/transmitter.js

@@ -0,0 +1,92 @@
+"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.Transmitter = exports.getTransmitterName = void 0;
+const objects_1 = require("../objects");
+const operators_1 = require("../reactive/operators");
+const strings_1 = require("../strings");
+const time_1 = require("../time");
+const default_headers_1 = require("./default-headers");
+const error_codes_1 = require("./error-codes");
+const errors_1 = require("./errors");
+const interfaces_1 = require("./interfaces");
+const stream_event_1 = require("./stream-event");
+const TRANSMITTER_NAME_KEY = 'router-name';
+const getTransmitterName = (ctx) => ctx.getHeaders()[TRANSMITTER_NAME_KEY];
+exports.getTransmitterName = getTransmitterName;
+class Transmitter {
+    constructor(options) {
+        var _a;
+        this.options = options;
+        this.id = this.options.id || strings_1.strings.random(10);
+        this.alias = this.options.alias || interfaces_1.DEFAULT_ALIAS;
+        this.connection = this.options.connection;
+        this.timeoutDuration = (_a = this.options.timeoutDuration) !== null && _a !== void 0 ? _a : time_1.time.second * 10;
+        this.interceptors = [];
+    }
+    addInterceptor(interceptor) {
+        this.interceptors.push(interceptor);
+    }
+    send(event, { body, headers = {} } = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const streamEvent = this.runInterceptors(this.createRequest(event, body, headers));
+            const reply = new Promise((res, rej) => __awaiter(this, void 0, void 0, function* () {
+                let hasComplete = false;
+                const timeout = setTimeout(() => {
+                    if (!hasComplete) {
+                        rej(new errors_1.ContextualError(`Request timed out for ${event}`, {
+                            code: error_codes_1.ErrorCodes.REQUEST_TIMEOUT_ERROR,
+                        }));
+                        hasComplete = true;
+                    }
+                }, this.timeoutDuration);
+                const onMessage = (0, operators_1.pipe)(this.connection.onMessage)((0, operators_1.first)((req) => req.ID === streamEvent.ID));
+                onMessage.subscribe((sourceEvent) => {
+                    if (hasComplete) {
+                        return;
+                    }
+                    clearTimeout(timeout);
+                    if (!sourceEvent) {
+                        rej(new errors_1.ContextualError(`Wrong request format for ${event}`, {
+                            code: error_codes_1.ErrorCodes.REQUEST_FORMAT_ERROR,
+                        }));
+                        return;
+                    }
+                    const updatedEvent = this.runInterceptors(sourceEvent);
+                    if (updatedEvent.hasError === true) {
+                        rej(updatedEvent.body);
+                    }
+                    else {
+                        res(updatedEvent);
+                    }
+                });
+            }));
+            this.connection.send(streamEvent);
+            return reply;
+        });
+    }
+    runInterceptors(req) {
+        const ctx = (0, objects_1.cloneDeep)(req);
+        for (const interceptor of this.interceptors) {
+            interceptor(ctx);
+        }
+        return ctx;
+    }
+    createRequest(event, body, headers) {
+        return new stream_event_1.StreamEvent({
+            ID: strings_1.strings.random(10),
+            eventType: event,
+            body,
+            headers: Object.assign({ [default_headers_1.DefaultEventHeaders.SenderAlias]: this.alias, [default_headers_1.DefaultEventHeaders.SenderId]: this.id }, headers),
+        });
+    }
+}
+exports.Transmitter = Transmitter;

package/node_modules/@rokt/kit/cjs/strings/format.d.ts

@@ -0,0 +1 @@
+export declare const format: <T extends Record<string, string> = Record<string, string>>(target: string, data: T) => string;

package/node_modules/@rokt/kit/cjs/strings/format.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.format = void 0;
+const format = (target, data) => {
+    for (const [key, value] of Object.entries(data)) {
+        target = target.replace(RegExp('\\{' + key + '\\}', 'gi'), value);
+    }
+    return target;
+};
+exports.format = format;

package/node_modules/@rokt/kit/cjs/strings/guid.d.ts

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

package/node_modules/@rokt/kit/cjs/strings/guid.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guid = void 0;
+const crypto_1 = require("../crypto");
+function guid() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => 
+    /* tslint:disable:no-bitwise */
+    ((c === 'y' ? 8 : 0) ^ (crypto_1.crypto.getRandomValues(new Uint8Array(1))[0] & (15 >> (c === 'y' ? 2 : 0)))).toString(16));
+}
+exports.guid = guid;

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

@@ -0,0 +1,3 @@
+export * from './random';
+export * from './format';
+export * from './guid';

package/node_modules/@rokt/kit/cjs/strings/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("./random"), exports);
+__exportStar(require("./format"), exports);
+__exportStar(require("./guid"), exports);

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

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

package/node_modules/@rokt/kit/cjs/strings/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.strings = void 0;
+const strings = __importStar(require("./index.barrel"));
+exports.strings = strings;

package/node_modules/@rokt/kit/cjs/strings/random.d.ts

@@ -0,0 +1 @@
+export declare function random(length?: number): string;

package/node_modules/@rokt/kit/cjs/strings/random.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.random = void 0;
+function random(length = 5) {
+    let result = '';
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    const charactersLength = characters.length;
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+}
+exports.random = random;

package/node_modules/@rokt/kit/cjs/testing/construct-mock.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="jest" />
+export declare function constructMock<T extends new (...args: any) => any>(constructor: T): jest.Mocked<InstanceType<T>>;

package/node_modules/@rokt/kit/cjs/testing/construct-mock.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constructMock = void 0;
+function constructMock(constructor) {
+    return new constructor();
+}
+exports.constructMock = constructMock;

package/node_modules/@rokt/kit/cjs/testing/flush-promises.d.ts

@@ -0,0 +1 @@
+export declare function flushPromises(): Promise<unknown>;

package/node_modules/@rokt/kit/cjs/testing/flush-promises.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flushPromises = void 0;
+function flushPromises() {
+    return new Promise((resolve) => setTimeout(resolve));
+}
+exports.flushPromises = flushPromises;

package/node_modules/@rokt/kit/cjs/testing/func.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="jest" />
+export declare const func: (fn: jest.Mock) => {
+    arg: (n: number) => any;
+    call: (n: number) => any;
+    get: () => any;
+    readonly expect: jest.JestMatchers<any>;
+};

package/node_modules/@rokt/kit/cjs/testing/func.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.func = void 0;
+const func = (fn) => {
+    let arg = 0;
+    let call = 0;
+    const setter = {
+        arg: (n) => {
+            arg = n;
+            return setter;
+        },
+        call: (n) => {
+            call = n;
+            return setter;
+        },
+        get: () => fn.mock.calls[call][arg],
+        get expect() {
+            return expect(fn.mock.calls[call][arg]);
+        },
+    };
+    return setter;
+};
+exports.func = func;

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

@@ -0,0 +1,5 @@
+export * from './func';
+export * from './flush-promises';
+export * from './mock-interface';
+export * from './parameters';
+export * from './promise-state';

package/node_modules/@rokt/kit/cjs/testing/index.barrel.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("./func"), exports);
+__exportStar(require("./flush-promises"), exports);
+__exportStar(require("./mock-interface"), exports);
+__exportStar(require("./parameters"), exports);
+__exportStar(require("./promise-state"), exports);

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

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

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

@@ -0,0 +1,32 @@
+"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 __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);
+};
+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.testing = void 0;
+__exportStar(require("./index.barrel"), exports);
+const testing = __importStar(require("./index.barrel"));
+exports.testing = testing;

package/node_modules/@rokt/kit/cjs/testing/mock-interface.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="jest" />
+export declare const initProperty: (target: any, prop: string | number | symbol) => void;
+export type MockInterface<T = any> = {
+    [K in keyof T]: T[K] & (T[K] extends (...args: infer A) => infer B ? jest.Mock<B, A> : MockInterface<T[K]>);
+};
+type AnyObject = {
+    [key: string | number | symbol]: any;
+};
+type MockInterfaceConstructor = {
+    new <T = any>(base?: AnyObject | Partial<T>): MockInterface<T>;
+    extend<T>(constructor: any): new <U extends T>() => MockInterface<U>;
+};
+export declare const MockInterface: MockInterfaceConstructor;
+/**
+ * @deprecated Use `new MockInterface()` instead
+ */
+export type MockedInterface<T = any> = MockInterface<T>;
+export declare const mockInterface: <T = any>(base?: AnyObject) => MockedInterface<T>;
+export {};

package/node_modules/@rokt/kit/cjs/testing/mock-interface.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockInterface = exports.MockInterface = exports.initProperty = void 0;
+// tslint:disable-next-line:only-arrow-functions
+function MockInterfaceBase(base = {}) {
+    const funcCache = new Map();
+    return new Proxy(base, {
+        get: (target, key) => {
+            var _a;
+            if (target.hasOwnProperty(key)) {
+                return target[key];
+            }
+            if (key === Symbol.iterator) {
+                return (_a = target[Symbol.iterator]) !== null && _a !== void 0 ? _a : Reflect.ownKeys(target)[Symbol.iterator];
+            }
+            if (key === 'then' || key === 'catch') {
+                return undefined;
+            }
+            let func = funcCache.get(key);
+            if (!func) {
+                func = jest.fn();
+                funcCache.set(key, func);
+            }
+            return func;
+        },
+        set: (target, prop, value) => {
+            target[prop] = value;
+            return true;
+        },
+    });
+}
+MockInterfaceBase.extend = (constructor) => {
+    // tslint:disable-next-line:only-arrow-functions
+    return function () {
+        const instance = new constructor();
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-expect-error
+        return new MockInterfaceBase(instance);
+    };
+};
+const initProperty = (target, prop) => {
+    target[prop] = undefined;
+};
+exports.initProperty = initProperty;
+exports.MockInterface = MockInterfaceBase;
+exports.mockInterface = MockInterfaceBase;

package/node_modules/@rokt/kit/cjs/testing/parameters.d.ts

@@ -0,0 +1,2 @@
+export type ParameterList<T> = T extends new (...args: infer C) => any ? C : T extends (...args: infer F) => any ? F : never;
+export declare const parameterList: <T>(target: T) => ParameterList<T>;

package/node_modules/@rokt/kit/cjs/testing/parameters.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parameterList = void 0;
+const parameterList = (target) => {
+    const params = new Array(target.length);
+    return params;
+};
+exports.parameterList = parameterList;

package/node_modules/@rokt/kit/cjs/testing/promise-state.d.ts

@@ -0,0 +1,7 @@
+export type PromiseState = (typeof PromiseState)[keyof typeof PromiseState];
+export declare const PromiseState: {
+    readonly Pending: "Pending";
+    readonly Resolved: "Resolved";
+    readonly Rejected: "Rejected";
+};
+export declare const getPromiseState: (target: Promise<any>) => Promise<PromiseState>;

package/node_modules/@rokt/kit/cjs/testing/promise-state.js

@@ -0,0 +1,33 @@
+"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.getPromiseState = exports.PromiseState = void 0;
+exports.PromiseState = {
+    Pending: 'Pending',
+    Resolved: 'Resolved',
+    Rejected: 'Rejected',
+};
+const key = {};
+const getPromiseState = (target) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const result = yield Promise.race([target, Promise.resolve(key)]);
+        if (result === key) {
+            return exports.PromiseState.Pending;
+        }
+        else {
+            return exports.PromiseState.Resolved;
+        }
+    }
+    catch (error) {
+        return exports.PromiseState.Rejected;
+    }
+});
+exports.getPromiseState = getPromiseState;