@genesislcap/foundation-testing 14.137.1-alpha-ee4af66.0 → 14.137.1

package/dist/cjs/component/fixture.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixture = void 0;
+const tslib_1 = require("tslib");
+const fast_element_1 = require("@microsoft/fast-element");
+const fast_foundation_1 = require("@microsoft/fast-foundation");
+function findElement(view) {
+    let current = view.firstChild;
+    while (current !== null && current.nodeType !== 1) {
+        current = current.nextSibling;
+    }
+    return current;
+}
+function isElementRegistry(obj) {
+    return typeof obj.register === 'function';
+}
+/**
+ * Creates a test fixture suitable for testing custom elements, templates, and bindings.
+ * @param templateNameOrRegistry - An HTML template or single element name to create the fixture for.
+ * @param options - Enables customizing fixture creation behavior.
+ * @returns A promise of the test fixture {@link Fixture}.
+ *
+ * @public
+ * @remarks
+ * Yields control to the caller one Microtask later, in order to
+ * ensure that the DOM has settled. This has changed in the latest version of FAST!
+ */
+function fixture(templateNameOrRegistry, options = {}) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const document = options.document || globalThis.document;
+        const parent = options.parent || document.createElement('div');
+        const source = options.source || {};
+        const context = options.context || fast_element_1.defaultExecutionContext;
+        if (typeof templateNameOrRegistry === 'string') {
+            const html = `<${templateNameOrRegistry}></${templateNameOrRegistry}>`;
+            templateNameOrRegistry = new fast_element_1.ViewTemplate(html, []);
+        }
+        else if (isElementRegistry(templateNameOrRegistry)) {
+            templateNameOrRegistry = [templateNameOrRegistry];
+        }
+        if (Array.isArray(templateNameOrRegistry)) {
+            const first = templateNameOrRegistry[0];
+            const ds = options.designSystem || fast_foundation_1.DesignSystem.getOrCreate(parent);
+            let prefix = '';
+            ds.register(templateNameOrRegistry, {
+                register(container, dsContext) {
+                    prefix = dsContext.elementPrefix;
+                },
+            });
+            const elementName = `${prefix}-${first.definition.baseName}`;
+            const html = `<${elementName}></${elementName}>`;
+            templateNameOrRegistry = new fast_element_1.ViewTemplate(html, []);
+        }
+        const view = templateNameOrRegistry.create();
+        const element = findElement(view);
+        let isConnected = false;
+        view.bind(source, context);
+        view.appendTo(parent);
+        customElements.upgrade(parent);
+        // Hook into the Microtask Queue to ensure the DOM is settled
+        // before yielding control to the caller.
+        yield Promise.resolve();
+        const connect = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (isConnected) {
+                return;
+            }
+            isConnected = true;
+            document.body.appendChild(parent);
+            yield Promise.resolve();
+        });
+        const disconnect = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (!isConnected) {
+                return;
+            }
+            isConnected = false;
+            document.body.removeChild(parent);
+            yield Promise.resolve();
+        });
+        return {
+            document,
+            template: templateNameOrRegistry,
+            view,
+            parent,
+            element,
+            connect,
+            disconnect,
+        };
+    });
+}
+exports.fixture = fixture;

package/dist/cjs/component/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./fixture"), exports);

package/dist/cjs/index.federated.js

@@ -0,0 +1,24 @@
+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;
+};
+Promise.resolve().then(() => __importStar(require('./index')));

package/dist/cjs/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Registration = void 0;
+const tslib_1 = require("tslib");
+/**
+ * Implemented by objects that wish to register dependencies in the container
+ * by creating resolvers.
+ * @public
+ */
+var fast_foundation_1 = require("@microsoft/fast-foundation");
+Object.defineProperty(exports, "Registration", { enumerable: true, get: function () { return fast_foundation_1.Registration; } });
+tslib_1.__exportStar(require("./component"), exports);
+tslib_1.__exportStar(require("./suite"), exports);
+tslib_1.__exportStar(require("./utils"), exports);
+tslib_1.__exportStar(require("./uvu"), exports);

package/dist/cjs/jsdom/setup.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.teardown = exports.setup = void 0;
+const tslib_1 = require("tslib");
+const jsdom_1 = require("jsdom");
+/**
+ * Jsdom setup.
+ * @public
+ */
+const setup = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const { window } = new jsdom_1.JSDOM('<!DOCTYPE html><html lang="en"><head></head><body></body></html>', {
+        pretendToBeVisual: true,
+        url: 'https://localhost',
+    });
+    window.matchMedia = () => ({
+        matches: false,
+        addListener: () => { },
+        removeListener: () => { },
+    });
+    /**
+     * There may have been a change to how the `CSSOM.parse(rule)` works, and how invalid rules are treated. Here we'll be
+     * more torrential of such issues given the limitations of JSDOM.
+     */
+    const cssInsertRule = window.CSSStyleSheet.prototype.insertRule;
+    window.CSSStyleSheet.prototype.insertRule = function (rule, index) {
+        try {
+            return cssInsertRule.call(this, rule, index);
+        }
+        catch (e) {
+            if (rule.includes('@import')) {
+                /**
+                 * Longstanding issue it seems, https://github.com/jsdom/jsdom/issues/2124
+                 */
+                console.log('Please note JSDOM does not support @import, skipping insertion.');
+            }
+            else {
+                /**
+                 * Unknown malformation.
+                 */
+                console.log('The CSS rule you are inserting is likely malformed', rule);
+            }
+            /**
+             * Return index as if were successful.
+             */
+            return index;
+        }
+    };
+    window.ResizeObserver = class ResizeObserver {
+        constructor(callback) {
+            this.callback = callback;
+        }
+        observe() { }
+        disconnect() { }
+        triggerResize(width, height) {
+            this.callback([{ contentRect: { width, height } }]);
+        }
+    };
+    globalThis.window = window;
+    globalThis.customElements = window.customElements;
+    globalThis.CSSImportRule = window.CSSImportRule;
+    globalThis.CSSMediaRule = window.CSSMediaRule;
+    globalThis.CSSRule = window.CSSRule;
+    globalThis.CSSStyleDeclaration = window.CSSStyleDeclaration;
+    globalThis.CSSStyleRule = window.CSSStyleRule;
+    globalThis.CSSStyleSheet = window.CSSStyleSheet;
+    globalThis.CustomEvent = window.CustomEvent;
+    globalThis.document = window.document;
+    globalThis.Document = window.Document;
+    globalThis.DocumentFragment = window.DocumentFragment;
+    globalThis.HTMLDialogElement = window.HTMLDialogElement;
+    globalThis.HTMLElement = window.HTMLElement;
+    globalThis.HTMLInputElement = window.HTMLInputElement;
+    globalThis.HTMLOptionElement = window.HTMLOptionElement;
+    globalThis.HTMLSelectElement = window.HTMLSelectElement;
+    globalThis.HTMLStyleElement = window.HTMLStyleElement;
+    globalThis.KeyboardEvent = window.KeyboardEvent;
+    globalThis.localStorage = window.localStorage;
+    globalThis.sessionStorage = window.sessionStorage;
+    globalThis.MutationObserver = window.MutationObserver;
+    globalThis.navigator = window.navigator;
+    globalThis.location = window.location;
+    globalThis.Node = window.Node;
+    globalThis.Option = window.Option;
+    globalThis.requestAnimationFrame = window.requestAnimationFrame;
+    globalThis.ShadowRoot = window.ShadowRoot;
+    // Env Variables
+    globalThis.FORCE_HTTP = false;
+    globalThis.HTTP_CONFIG = '';
+});
+exports.setup = setup;
+/**
+ * Jsdom teardown / cleanup.
+ * @public
+ * @remarks
+ * This strictly is not required, but may be useful for certain test runs. If used, be mindful that you will need to
+ * call setup again before the next test run.
+ */
+const teardown = () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    delete window.matchMedia;
+    delete globalThis.window;
+    delete globalThis.customElements;
+    delete globalThis.CSSImportRule;
+    delete globalThis.CSSMediaRule;
+    delete globalThis.CSSRule;
+    delete globalThis.CSSStyleDeclaration;
+    delete globalThis.CSSStyleRule;
+    delete globalThis.CSSStyleSheet;
+    delete globalThis.CustomEvent;
+    delete globalThis.document;
+    delete globalThis.Document;
+    delete globalThis.DocumentFragment;
+    delete globalThis.HTMLDialogElement;
+    delete globalThis.HTMLElement;
+    delete globalThis.HTMLInputElement;
+    delete globalThis.HTMLOptionElement;
+    delete globalThis.HTMLSelectElement;
+    delete globalThis.HTMLStyleElement;
+    delete globalThis.KeyboardEvent;
+    delete globalThis.localStorage;
+    delete globalThis.MutationObserver;
+    delete globalThis.navigator;
+    delete globalThis.location;
+    delete globalThis.Node;
+    delete globalThis.Option;
+    delete globalThis.requestAnimationFrame;
+    delete globalThis.ShadowRoot;
+    // Env Variables
+    delete globalThis.FORCE_HTTP;
+    delete globalThis.HTTP_CONFIG;
+    /**
+     * Cancel all timers etc.
+     */
+    window.close();
+});
+exports.teardown = teardown;
+/**
+ * Run setup on import by default.
+ */
+(0, exports.setup)();

package/dist/cjs/playwright/config.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configDefaults = void 0;
+/**
+ * Default Global Configs, to be re-used (and possibly overridden) by each app
+ * @public
+ */
+exports.configDefaults = {
+    globalSetup: '@genesislcap/foundation-testing/playwright',
+    projects: [
+        {
+            name: 'Chrome Stable',
+            use: {
+                browserName: 'chromium',
+                channel: 'chrome',
+                ignoreHTTPSErrors: true,
+                /**
+                 * We should be able to use these 'use' blocks at the App level to provide config data to our micro frontends.
+                 * This might include what backend to run against, what username password combo to use etc.
+                 *
+                 * config: AppLevelPkgConfig;
+                 */
+                // config: {
+                //   API_HOST: 'wss://dev-foundation1/gwf/',
+                //   DEFAULT_USER: process.env.DEFAULT_USER,
+                //   DEFAULT_PASSWORD: process.env.DEFAULT_PASSWORD,
+                //   PORT: 5030,
+                // },
+            },
+        },
+    ],
+    testMatch: '**/*.e2e.ts',
+    timeout: 60000,
+    webServer: {
+        command: 'npm run dev:no-open',
+        url: `http://localhost:${process.env.PORT}`,
+        timeout: 120000,
+        reuseExistingServer: !process.env.CI,
+    },
+    use: {
+        baseURL: `http://localhost:${process.env.PORT}`,
+    },
+};

package/dist/cjs/playwright/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/**
+ * Do not export setup
+ */
+tslib_1.__exportStar(require("./config"), exports);
+tslib_1.__exportStar(require("./test"), exports);

package/dist/cjs/playwright/setup.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+/**
+ * @param config - A playwright configuration object.
+ * @returns A teardown function.
+ *
+ * @public
+ * @example
+ * An example demonstrating use of environment variables and temporary folder:
+ * ```
+ * import rimraf from 'rimraf';
+ *
+ * async function setup(config: FullConfig) {
+ *  process.env.FOO = 'some data';
+ *  process.env.BAR = JSON.stringify({ some: 'data' });
+ *  return async function teardown() {
+ *    delete process.env.FOO;
+ *    delete process.env.BAR;
+ *    const tmpDirPath = path.join(os.tmpdir(), 'tmp-folder');
+ *    rimraf(tmpDirPath, console.log);
+ *   };
+ * }
+ * ```
+ */
+function setup(config) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return function teardown() {
+            return tslib_1.__awaiter(this, void 0, void 0, function* () { });
+        };
+    });
+}
+exports.default = setup;

package/dist/cjs/playwright/test.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test = exports.defaultAuditThresholds = exports.playAudit = exports.base = exports.expect = void 0;
+const tslib_1 = require("tslib");
+const test_1 = require("@playwright/test");
+const portfinder_sync_1 = require("portfinder-sync");
+var test_2 = require("@playwright/test");
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return test_2.expect; } });
+var test_3 = require("@playwright/test");
+Object.defineProperty(exports, "base", { enumerable: true, get: function () { return test_3.test; } });
+var playwright_lighthouse_1 = require("playwright-lighthouse");
+Object.defineProperty(exports, "playAudit", { enumerable: true, get: function () { return playwright_lighthouse_1.playAudit; } });
+const DEFAULT_PORT = 5030;
+const defaultPackageConfig = {
+    API_HOST: process.env.API_HOST,
+    DEFAULT_USER: process.env.DEFAULT_USER,
+    DEFAULT_PASSWORD: process.env.DEFAULT_PASSWORD,
+    PORT: Number(process.env.PORT || DEFAULT_PORT),
+};
+exports.defaultAuditThresholds = {
+    performance: 20,
+    accessibility: 20,
+    'best-practices': 20,
+    seo: 20,
+    pwa: 20, // 30,
+};
+/**
+ * Playwright test
+ * @public
+ * @remarks
+ * This is just an example playwright test fixture stub. In reality, you will likely create a custom
+ * fixture for your e2e tests depending on the needs of your app or micro frontend.
+ */
+exports.test = test_1.test.extend({
+    config: [defaultPackageConfig, { option: true, scope: 'worker', timeout: 60000 }],
+    port: [
+        ({ config }, use) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const port = (0, portfinder_sync_1.getPort)((config === null || config === void 0 ? void 0 : config.PORT) || process.env.PORT || defaultPackageConfig.PORT);
+            yield use(port);
+        }),
+        { scope: 'worker' }, // option: true
+    ],
+    browser: [
+        ({ port }, use) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+            const browser = yield test_1.chromium.launch({
+                args: [`--remote-debugging-port=${port}`],
+            });
+            yield use(browser);
+        }),
+        { scope: 'worker' },
+    ],
+    audit: [exports.defaultAuditThresholds, { option: true, scope: 'worker' }], // TODO: These are not being used from other test setups extending this.
+});
+// Perhaps we keen extending the test up the package chain... spread the mf tests into our app test
+// const test2 = test.extend<{ foo: boolean }>({
+//   foo: [true, { option: true }],
+// });
+//
+// a('lighthouse audit', async ({ foo, page }) => {
+//
+// });

package/dist/cjs/suite/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./suite"), exports);

package/dist/cjs/suite/suite.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogicSuite = exports.createComponentSuite = exports.runCases = exports.sinon = void 0;
+const tslib_1 = require("tslib");
+const fast_foundation_1 = require("@microsoft/fast-foundation");
+const component_1 = require("../component");
+const utils_1 = require("../utils");
+const uvu_1 = require("../uvu");
+var sinon_1 = require("sinon");
+Object.defineProperty(exports, "sinon", { enumerable: true, get: function () { return tslib_1.__importDefault(sinon_1).default; } });
+/**
+ * Assert a set of test cases.
+ * @param fn - The function to test.
+ * @param cases - An array of test cases to run against the function.
+ * @param assertion - Optional uvu assertion method, defaults to assert.equal.
+ * @public
+ * @remarks
+ * This is available as part of the suite context, but can also be run standalone.
+ */
+function runCases(fn, cases, assertion = uvu_1.assert.equal) {
+    uvu_1.assert.type(fn, 'function');
+    cases.forEach(([actual, expects, msg], index) => assertion(fn(...actual), expects, msg !== null && msg !== void 0 ? msg : JSON.stringify(actual, null, 2)));
+}
+exports.runCases = runCases;
+/**
+ * Create component test suite.
+ *
+ * @example
+ * Simple suite using the tag name of the component.
+ * ```ts
+ * import { createComponentSuite } from '@genesislcap/foundation-testing';
+ * import { Component } from './component';
+ * Component; // < As we're using tag name in the Suite, we hold a reference to avoid tree shaking.
+ * const Suite = createComponentSuite<Component>('Component', 'my-component');
+ * // test cases...
+ * Suite.run();
+ * ```
+ *
+ * @example
+ * Mocking a DI dependency for a composable component.
+ * ```ts
+ * const connectMock = new ConnectMock();
+ * const mocks = [Registration.instance(Connect, connectMock)];
+ * const Suite = createComponentSuite<ConnectionIndicator>('ConnectionIndicator Component', () => connectionIndicator(), null, mocks);
+ * // test cases...
+ * Suite.run();
+ * ```
+ *
+ * @example
+ * An element will be required to test anything that directly or in-directly makes use of the DI container, for example,
+ * a service that can be injected into components, or has its own injected dependencies.
+ * ```ts
+ * import { Service } from './service';
+ * @customElement({
+ *   name: 'test-element',
+ *   template: html`<slot></slot>`,
+ * })
+ * class TestElement extends FASTElement {}
+ * const mocks = [...];
+ * const Suite = createComponentSuite<TestElement>('Service', 'test-element', null, mocks);
+ * // test cases...
+ * Suite.run();
+ * ```
+ *
+ * Importing the service should invoke the Service's DI registration, so in your test cases you can simply query the
+ * container to get a reference to your service.
+ * ```ts
+ * Suite('Service.x does something expected', async ({ container }) => {
+ *   const myService = container.get(Service);
+ *   // assert
+ * });
+ * ```
+ *
+ * You can optionally add the service to the test element for lookup convenience, but this is not required.
+ * ```ts
+ * class TestElement extends FASTElement {
+ *   @Service service: Service;
+ * }
+ * Suite('Element has service injected', async ({ element }) => {
+ *   assert.ok(element.service);
+ * });
+ * ```
+ *
+ * @typeParam TElement - The element interface.
+ * @param title - Title of the test suite
+ * @param elementNameOrGetter - Element tag name or getter which is used to create the element within the fixture
+ * @param context - Optional component context {@link ComponentContext}
+ * @param registrations - Optional array of DI container registrations
+ * @returns The test suite
+ * @public
+ * @remarks
+ * Used to test function output given certain input arguments.
+ */
+function createComponentSuite(title, elementNameOrGetter, context, registrations = []) {
+    const Suite = (0, uvu_1.suite)(title, Object.assign({ element: undefined, disconnect: undefined, designSystem: undefined, container: undefined, runCases: undefined }, context));
+    Suite.before.each((c) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            const parent = document.createElement('div');
+            const designSystem = fast_foundation_1.DesignSystem.getOrCreate(parent).register(...registrations);
+            const container = fast_foundation_1.DI.getOrCreateDOMContainer(parent);
+            const fixtureOptions = {
+                parent,
+                designSystem,
+            };
+            /**
+             * We might need to spread element getters for some test case, for example look at the following Fast test:
+             * packages/web-components/fast-foundation/src/picker/picker.spec.ts
+             */
+            const { element, connect, disconnect } = yield (0, component_1.fixture)(typeof elementNameOrGetter === 'string' ? elementNameOrGetter : elementNameOrGetter(), fixtureOptions);
+            c.element = element;
+            c.disconnect = disconnect;
+            c.designSystem = designSystem;
+            c.container = container;
+            c.runCases = runCases.bind(Suite);
+            yield connect();
+        }
+        catch (e) {
+            utils_1.logger.error(e);
+            throw e;
+        }
+    }));
+    /* eslint-disable require-atomic-updates */
+    Suite.after.each((c) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        try {
+            if (c.disconnect) {
+                yield c.disconnect();
+            }
+            c.element = undefined;
+            c.disconnect = undefined;
+            c.designSystem = undefined;
+            c.container = undefined;
+            c.runCases = undefined;
+        }
+        catch (e) {
+            utils_1.logger.error(e);
+            throw e;
+        }
+    }));
+    return Suite;
+}
+exports.createComponentSuite = createComponentSuite;
+/**
+ * Create logic test suite.
+ *
+ * @example
+ * ```ts
+ * import { createLogicSuite } from '@genesislcap/foundation-testing';
+ * import { myFunction } from './logic';
+ * const Suite = createLogicSuite('myFunction');
+ * Suite('myFunction should provide expected results', ({ runCases }) => {
+ *   runCases(myFunction, [
+ *     [['1'], true],
+ *     [[123], true],
+ *     [['60%'], true],
+ *     [['$60'], false],
+ *     [['1.1'], false],
+ *     [[''], false],
+ *     [[true], false],
+ *     [[null], false],
+ *     [[undefined], false],
+ *   ]);
+ * });
+ * Suite.run();
+ * ```
+ *
+ * @typeParam TContext - The context interface.
+ * @param title - Title of the test suite
+ * @param context - Optional context which extends {@link LogicContext}
+ * @returns The test suite
+ * @public
+ * @remarks
+ * Used to test function output given certain input arguments.
+ */
+function createLogicSuite(title, context) {
+    const Suite = (0, uvu_1.suite)(title, Object.assign({ runCases: (fn, cases) => {
+            uvu_1.assert.type(fn, 'function');
+            cases.forEach(([actual, expects, msg]) => uvu_1.assert.is(fn(...actual), expects, msg));
+        } }, context));
+    return Suite;
+}
+exports.createLogicSuite = createLogicSuite;

package/dist/cjs/tsm/index.js

@@ -0,0 +1,27 @@
+/**
+ * Shared tsm config for apps to import and use in their tsm.js files.
+ *
+ * @example
+ * ```js
+ * const config = require('@genesislcap/foundation-testing/tsm');
+ *
+ * module.exports = config;
+ * ```
+ *
+ * @public
+ */
+const config = {
+    '.css': {
+        loader: 'text',
+    },
+    '.svg': {
+        loader: 'dataurl',
+    },
+    '.jpg': {
+        loader: 'dataurl',
+    },
+    '.png': {
+        loader: 'dataurl',
+    },
+};
+module.exports = config;

package/dist/cjs/utils/harness.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreTestHarness = exports.resetTestHarness = exports.testSpy = void 0;
+const tslib_1 = require("tslib");
+const sinon_1 = tslib_1.__importDefault(require("sinon"));
+/**
+ * Predicate function used to check whether the object's value is a function
+ * we want to spy on. We want to spy on all functions, except the constructor
+ * @internal
+ */
+const shouldSpy = (proto) => (k) => typeof proto[k] === 'function' && k !== 'constructor';
+/**
+ * Decorator: Used on a test harness class based on a `FoundationElement` to give it extra functionality
+ * which can be used during testing. *Important* this is to be used on a parent element compared to
+ * the element under test.
+ *
+ *
+ * @remarks
+ * Access the test functionality using the type with {@link WithTestHarness}
+ *
+ * Reset after each test with {@link resetTestHarness}
+ *
+ * @example
+ *
+ * // Testing the first function call
+ * async (\{ element \}) =\> \{
+ *
+    assert.ok(
+      element.layout.addItemFromChild.calledWith(\{
+        type: 'component',
+        componentType: 'test',
+        title: `Item test`,
+        reorderEnabled: true,
+        isClosable: false,
+        size: undefined,
+      \})
+    );
+ *
+ *   // Reset the tester at the end of every test even if you don't assert on any of it!
+*   resetTestHarness(element.layout);
+ * \}
+ *
+ * @public
+ */
+function testSpy(constructor) {
+    constructor['_test'] = sinon_1.default.createSandbox();
+    Object.getOwnPropertyNames(constructor.prototype)
+        .filter(shouldSpy(constructor.prototype))
+        .forEach((p) => constructor['_test'].spy(constructor.prototype, p));
+}
+exports.testSpy = testSpy;
+/**
+ * Resets the history of the spied functions on the objects so previous running tests
+ * don't affect the current test.
+ * Must be called at the end of every test even if not asserting on the spies.
+ * @param wrapper - `WithTestHarness<T>` object to reset
+ * @public
+ */
+function resetTestHarness(wrapper) {
+    wrapper.constructor['_test'].resetHistory();
+}
+exports.resetTestHarness = resetTestHarness;
+/**
+ * Restores the spied functions back to the original functions without the spies.
+ * @param wrapper - `WithTestHarness<T>` object to restore
+ * @public
+ */
+function restoreTestHarness(wrapper) {
+    wrapper.constructor['_test'].restore();
+}
+exports.restoreTestHarness = restoreTestHarness;

package/dist/cjs/utils/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./logger"), exports);
+tslib_1.__exportStar(require("./harness"), exports);
+tslib_1.__exportStar(require("./promise"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/dist/cjs/utils/logger.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const foundation_logger_1 = require("@genesislcap/foundation-logger");
+/**
+ * Test logger
+ * @public
+ * @remarks
+ * Exported so you can set log levels differently across packages when needed.
+ */
+exports.logger = (0, foundation_logger_1.createLogger)('foundation-testing');

package/dist/cjs/utils/promise.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.delayedResolve = void 0;
+const tslib_1 = require("tslib");
+/**
+ * Delayed resolve utility.
+ *
+ * @example
+ * ```ts
+ * test('delayed resolve', async () => {
+ *   const mockAPI = delayedResolve({ foo: 'bar' }, 2_000);
+ *   const result = await mockAPI();
+ * });
+ * ```
+ * @param result - The result of the promise.
+ * @param duration - An optional duration in milliseconds. Defaults to 500.
+ * @public
+ */
+const delayedResolve = (result, duration = 500) => () => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    yield new Promise((resolve) => {
+        setTimeout(resolve, duration);
+    });
+    return result;
+});
+exports.delayedResolve = delayedResolve;

package/dist/cjs/utils/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// https://github.com/type-challenges/type-challenges/blob/main/utils/index.d.ts
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/uvu/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./uvu"), exports);

package/dist/cjs/uvu/uvu.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeout = exports.test = exports.suite = exports.assert = void 0;
+const tslib_1 = require("tslib");
+const uvu_1 = require("uvu");
+Object.defineProperty(exports, "suite", { enumerable: true, get: function () { return uvu_1.suite; } });
+Object.defineProperty(exports, "test", { enumerable: true, get: function () { return uvu_1.test; } });
+const assert = tslib_1.__importStar(require("uvu/assert"));
+exports.assert = assert;
+/**
+ * Timeout utility.
+ *
+ * @example A promise that never ends.
+ * ```ts
+ * test(
+ *   'should fail',
+ *   timeout(async () => {
+ *     await new Promise(() => {});
+ *     assert.ok(true);
+ *   }, 5_000),
+ * );
+ * ```
+ *
+ * @example A slow API.
+ * ```ts
+ * test(
+ *   'should fail',
+ *   timeout(async () => {
+ *     const slowMockAPI = delayedResolve({ foo: 'bar' }, 4_000);
+ *     await slowMockAPI();
+ *     assert.unreachable('should have timed out');
+ *   }, 2_000),
+ * );
+ * ```
+ *
+ * @param callback - The async test function.
+ * @param duration - An optional duration in milliseconds. Defaults to 5_000.
+ * @public
+ */
+const timeout = (callback, duration = 5000) => {
+    return (context) => {
+        let timer;
+        return Promise.race([
+            callback(context),
+            new Promise((resolve, reject) => {
+                timer = setTimeout(() => reject(new Error('timed out')), duration);
+            }),
+        ]).finally(() => {
+            clearTimeout(timer);
+        });
+    };
+};
+exports.timeout = timeout;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@genesislcap/foundation-testing",
   "description": "Genesis Foundation Testing",
-  "version": "14.137.1-alpha-ee4af66.0",
+  "version": "14.137.1",
   "sideEffects": false,
   "license": "SEE LICENSE IN license.txt",
   "main": "dist/esm/index.js",
@@ -16,14 +16,17 @@
     },
     "./e2e": {
       "types": "./dist/dts/playwright/index.d.ts",
+      "require": "./dist/cjs/playwright/index.js",
       "default": "./dist/esm/playwright/index.js"
     },
     "./jsdom": {
       "types": "./dist/dts/jsdom/setup.d.ts",
+      "require": "./dist/cjs/jsdom/setup.js",
       "default": "./dist/esm/jsdom/setup.js"
     },
     "./playwright": {
       "types": "./dist/dts/playwright/setup.d.ts",
+      "require": "./dist/cjs/playwright/setup.js",
       "default": "./dist/esm/playwright/setup.js"
     },
     "./package.json": "./package.json",
@@ -48,7 +51,7 @@
   "scripts": {
     "api:extract": "api-extractor run",
     "api:document": "api-documenter markdown -i dist -o docs/api",
-    "build": "npm run clean && tsc -b ./tsconfig.json && npm run api:extract && npm run api:document",
+    "build": "npm run clean && tsc -b ./tsconfig.json && tsc -b ./tsconfig.cjs.json && npm run api:extract && npm run api:document",
     "clean": "rimraf dist tsconfig.tsbuildinfo",
     "dev": "tsc -b ./tsconfig.json -w",
     "test": "uvu -r tsm --tsmconfig ./src/tsm/tsm.ts -r @esbuild-kit/cjs-loader -r ./src/jsdom/setup.ts . test.ts"
@@ -63,7 +66,7 @@
     "typescript": "^4.5.5"
   },
   "dependencies": {
-    "@genesislcap/foundation-logger": "14.137.1-alpha-ee4af66.0",
+    "@genesislcap/foundation-logger": "14.137.1",
     "@microsoft/fast-element": "^1.12.0",
     "@microsoft/fast-foundation": "^2.49.4",
     "@playwright/test": "^1.18.1",
@@ -84,5 +87,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "9a17853104201af371b3b3400262f18d941333fc"
+  "gitHead": "518e1b48a6dce0a411fcdafd7cb79f9098744aff"
 }

package/tsconfig.cjs.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": false,
+    "declarationDir": null,
+    "declarationMap": false,
+    "module": "CommonJS",
+    "outDir": "./dist/cjs"
+  }
+}