@augment-vir/test 30.0.0

package/LICENSE-CC0

@@ -0,0 +1,121 @@
+CC0 1.0 Universal
+
+Creative Commons Legal Code
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

package/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 electrovir
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/augments/test-web.d.ts

@@ -0,0 +1,13 @@
+import { RuntimeEnvError } from '@augment-vir/core';
+declare function importWebTestApi(): Promise<RuntimeEnvError | {
+    cleanupRender: typeof import("@open-wc/testing-helpers/types/src/fixtureWrapper").fixtureCleanup;
+    click: typeof import("../test-web/click-element").clickElement;
+    deleteInputText: typeof import("../test-web/type-into-element").deleteAllTextInInput;
+    ensureFocus: typeof import("../test-web/element-test-focus").focusElement;
+    moveMouseTo: typeof import("../test-web/click-element").moveToElement;
+    render: typeof import("@open-wc/testing-helpers/types/src/fixture-no-side-effect").fixture;
+    type: typeof import("../test-web/type-into-element").typeString;
+    typeIntoInput: typeof import("../test-web/type-into-element").typeStringIntoElement;
+}>;
+export declare const testWeb: Exclude<Awaited<ReturnType<typeof importWebTestApi>>, Error>;
+export {};

package/dist/augments/test-web.js

@@ -0,0 +1,21 @@
+import { isRuntimeEnv, RuntimeEnv, RuntimeEnvError } from '@augment-vir/core';
+async function importWebTestApi() {
+    if (!isRuntimeEnv(RuntimeEnv.Web)) {
+        return new RuntimeEnvError('The testWeb api cannot be used outside of a browser context.');
+    }
+    const { clickElement, moveToElement } = await import('../test-web/click-element');
+    const { focusElement } = await import('../test-web/element-test-focus');
+    const { cleanupFixture, renderFixture } = await import('../test-web/open-wc-exports');
+    const { deleteAllTextInInput, typeString, typeStringIntoElement } = await import('../test-web/type-into-element');
+    return {
+        cleanupRender: cleanupFixture,
+        click: clickElement,
+        deleteInputText: deleteAllTextInInput,
+        ensureFocus: focusElement,
+        moveMouseTo: moveToElement,
+        render: renderFixture,
+        type: typeString,
+        typeIntoInput: typeStringIntoElement,
+    };
+}
+export const testWeb = (await importWebTestApi());

package/dist/augments/universal-testing-suite/it-cases.d.ts

@@ -0,0 +1,21 @@
+import { ErrorMatchOptions, type CustomOutputAsserter } from '@augment-vir/assert';
+import { type AnyFunction, type TypedFunction } from '@augment-vir/core';
+export type BaseTestCase<OutputGeneric> = {
+    it: string;
+    only?: boolean | undefined;
+    skip?: boolean | undefined;
+} & ({
+    expect: OutputGeneric;
+} | {
+    throws: ErrorMatchOptions | undefined;
+});
+export type OutputTestCaseSingleInput<FunctionToTest extends AnyFunction> = {
+    input: Parameters<FunctionToTest>[0];
+} & BaseTestCase<Awaited<ReturnType<FunctionToTest>>>;
+export type OutputTestCaseMultipleInputs<FunctionToTest extends AnyFunction> = {
+    inputs: Parameters<FunctionToTest>['length'] extends never ? FunctionToTest extends TypedFunction<[infer ArgumentsType], any> ? ArgumentsType[] : never : Parameters<FunctionToTest>;
+} & BaseTestCase<Awaited<ReturnType<FunctionToTest>>>;
+export type FunctionTestCase<FunctionToTest extends AnyFunction> = 1 extends Parameters<FunctionToTest>['length'] ? Parameters<FunctionToTest>['length'] extends 0 | 1 ? OutputTestCaseSingleInput<FunctionToTest> : OutputTestCaseMultipleInputs<FunctionToTest> : 0 extends Parameters<FunctionToTest>['length'] ? BaseTestCase<Awaited<ReturnType<FunctionToTest>>> : OutputTestCaseMultipleInputs<FunctionToTest>;
+export declare function itCases<FunctionToTest extends AnyFunction>(functionToTest: FunctionToTest, testCases: ReadonlyArray<FunctionTestCase<typeof functionToTest>>): unknown[];
+export declare function itCases<FunctionToTest extends AnyFunction>(functionToTest: FunctionToTest, customAsserter: CustomOutputAsserter<typeof functionToTest>, testCases: ReadonlyArray<FunctionTestCase<typeof functionToTest>>): unknown[];
+export declare function itCases<FunctionToTest extends AnyFunction>(functionToTest: FunctionToTest, testCasesOrCustomAsserter: CustomOutputAsserter<typeof functionToTest> | ReadonlyArray<FunctionTestCase<typeof functionToTest>>, maybeTestCases?: ReadonlyArray<FunctionTestCase<typeof functionToTest>> | undefined): unknown[];

package/dist/augments/universal-testing-suite/it-cases.js

@@ -0,0 +1,54 @@
+import { assert, check } from '@augment-vir/assert';
+import { ensureErrorAndPrependMessage, } from '@augment-vir/core';
+import { it } from './universal-it.js';
+const unsetError = Symbol('unset-error');
+export function itCases(functionToTest, testCasesOrCustomAsserter, maybeTestCases) {
+    const testCases = (maybeTestCases ||
+        testCasesOrCustomAsserter);
+    if (!check.isArray(testCases)) {
+        throw new TypeError('expected an array of test cases');
+    }
+    const asserter = maybeTestCases ? testCasesOrCustomAsserter : assert.deepEquals;
+    if (typeof asserter !== 'function') {
+        throw new TypeError('expected a function for the custom asserter');
+    }
+    return testCases.map((testCase) => {
+        const itFunction = testCase.only ? it.only : testCase.skip ? it.skip : it;
+        return itFunction(testCase.it, async () => {
+            const functionInputs = 'input' in testCase
+                ? [testCase.input]
+                : 'inputs' in testCase
+                    ? testCase.inputs
+                    : // as cast here to cover the case where the input has NO inputs
+                        [];
+            if ('expect' in testCase) {
+                await assert.output(asserter, functionToTest, functionInputs, testCase.expect, testCase.it);
+            }
+            else {
+                let caughtError = unsetError;
+                try {
+                    await functionToTest(...functionInputs);
+                }
+                catch (thrownError) {
+                    caughtError = thrownError;
+                }
+                const errorThrower = () => {
+                    if (caughtError !== unsetError) {
+                        throw caughtError;
+                    }
+                };
+                // give a better name if possible
+                Object.defineProperty(errorThrower, 'name', {
+                    value: functionToTest.name,
+                });
+                const expectsAnError = !!(testCase.throws?.matchConstructor || testCase.throws?.matchMessage);
+                if (caughtError !== unsetError && !expectsAnError) {
+                    throw ensureErrorAndPrependMessage(caughtError, `${functionToTest.name} threw an unexpected error`);
+                }
+                else if (expectsAnError) {
+                    assert.throws(errorThrower, testCase.throws, 'Caught error did not match expectations');
+                }
+            }
+        });
+    });
+}

package/dist/augments/universal-testing-suite/universal-describe.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A minimal interface for `describe` that is compatible with both Mocha ({@link mochaDescribe}) and
+ * Node.js's built-in test runner ({@link nodeDescribe}). This is used for {@link describe}.
+ *
+ * @category Testing:Common
+ */
+export type UniversalDescribe = UniversalBareDescribe & {
+    only: UniversalBareDescribe;
+    skip: UniversalBareDescribe;
+};
+/**
+ * An interface for the `describe` test function that is compatible with both Mocha
+ * ({@link mochaDescribe}) and Node.js's built-in test runner ({@link nodeDescribe}). This is used in
+ * {@link UniversalDescribe}. The only difference is that this type does not include `only` and
+ * `skip`.
+ *
+ * @category Testing:Common
+ */
+export type UniversalBareDescribe = (this: void, describeThis: string, callback: (this: void) => void) => void;
+export declare const describe: UniversalDescribe;

package/dist/augments/universal-testing-suite/universal-describe.js

@@ -0,0 +1,9 @@
+import { isRuntimeEnv, RuntimeEnv } from '@augment-vir/core';
+const describes = isRuntimeEnv(RuntimeEnv.Node)
+    ? {
+        node: (await import('node:test')).describe,
+    }
+    : {
+        mocha: globalThis.describe,
+    };
+export const describe = (describes.mocha || describes.node);

package/dist/augments/universal-testing-suite/universal-it.d.ts

@@ -0,0 +1,27 @@
+import { UniversalContext } from './universal-test-context.js';
+/**
+ * An interface for an `it` callback that is compatible with both Mocha ({@link mochaIt}) and
+ * Node.js's built-in test runner ({@link nodeIt}) and used in {@link UniversalIt}.
+ *
+ * @category Testing:Common
+ */
+export type UniversalItCallback = (this: void, context: UniversalContext) => Promise<void> | void;
+/**
+ * An interface for the `it` test function that is compatible with both Mocha ({@link mochaIt}) and
+ * Node.js's built-in test runner ({@link nodeIt}). This is used in {@link UniversalIt}. The only
+ * difference is that this type does not include `only` and `skip`.
+ *
+ * @category Testing:Common
+ */
+export type UniversalBareIt = (this: void, doesThis: string, callback: UniversalItCallback) => void;
+/**
+ * A minimal interface for `it` that is compatible with both Mocha ({@link mochaIt}) and Node.js's
+ * built-in test runner ({@link nodeIt}). This is used for {@link it}.
+ *
+ * @category Testing:Common
+ */
+export type UniversalIt = UniversalBareIt & {
+    only: UniversalBareIt;
+    skip: UniversalBareIt;
+};
+export declare const it: UniversalIt;

package/dist/augments/universal-testing-suite/universal-it.js

@@ -0,0 +1,9 @@
+import { isRuntimeEnv, RuntimeEnv } from '@augment-vir/core';
+const its = isRuntimeEnv(RuntimeEnv.Node)
+    ? {
+        node: (await import('node:test')).it,
+    }
+    : {
+        mocha: globalThis.it,
+    };
+export const it = (its.mocha || its.node);

package/dist/augments/universal-testing-suite/universal-test-context.d.ts

@@ -0,0 +1,14 @@
+import { RuntimeEnv } from '@augment-vir/core';
+import { TestContext as NodeTestContextImport } from 'node:test';
+import type { Mocha } from '../../mocha.js';
+export type MochaTestContext = Mocha.Context;
+export type NodeTestContext = NodeTestContextImport;
+export type UniversalContext = NodeTestContext | MochaTestContext;
+export type ContextByEnv = {
+    [RuntimeEnv.Node]: NodeTestContext;
+    [RuntimeEnv.Web]: Mocha.Context;
+};
+export declare function ensureTestContext<const SpecificEnv extends RuntimeEnv>(context: UniversalContext, env: RuntimeEnv): ContextByEnv[SpecificEnv];
+export declare function assertTestContext<const SpecificEnv extends RuntimeEnv>(context: UniversalContext, env: RuntimeEnv): asserts context is ContextByEnv[SpecificEnv];
+export declare function isTestContext<const SpecificEnv extends RuntimeEnv>(context: UniversalContext, env: RuntimeEnv): context is ContextByEnv[SpecificEnv];
+export declare function determineTestContextEnv(context: UniversalContext): RuntimeEnv;

package/dist/augments/universal-testing-suite/universal-test-context.js

@@ -0,0 +1,24 @@
+import { RuntimeEnv } from '@augment-vir/core';
+export function ensureTestContext(context, env) {
+    assertTestContext(context, env);
+    return context;
+}
+export function assertTestContext(context, env) {
+    const actualEnv = determineTestContextEnv(context);
+    if (actualEnv !== env) {
+        throw new TypeError();
+    }
+}
+export function isTestContext(context, env) {
+    try {
+        assertTestContext(context, env);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const nodeOnlyCheckKey = 'diagnostic';
+export function determineTestContextEnv(context) {
+    return context[nodeOnlyCheckKey] ? RuntimeEnv.Node : RuntimeEnv.Web;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './augments/test-web.js';
+export * from './augments/universal-testing-suite/it-cases.js';
+export * from './augments/universal-testing-suite/universal-describe.js';
+export * from './augments/universal-testing-suite/universal-it.js';
+export * from './augments/universal-testing-suite/universal-test-context.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './augments/test-web.js';
+export * from './augments/universal-testing-suite/it-cases.js';
+export * from './augments/universal-testing-suite/universal-describe.js';
+export * from './augments/universal-testing-suite/universal-it.js';
+export * from './augments/universal-testing-suite/universal-test-context.js';

package/dist/test-web/click-element.d.ts

@@ -0,0 +1,2 @@
+export declare function clickElement(element: Element): Promise<void>;
+export declare function moveToElement(element: Element): Promise<void>;

package/dist/test-web/click-element.js

@@ -0,0 +1,18 @@
+import { sendMouse } from '@web/test-runner-commands';
+import { getCenterOfElement } from './symlinked/element-position.js';
+async function sendMouseToMiddleOfElement(element, operationType) {
+    const center = getCenterOfElement(element);
+    await sendMouse({
+        position: [
+            center.x,
+            center.y,
+        ],
+        type: operationType,
+    });
+}
+export async function clickElement(element) {
+    await sendMouseToMiddleOfElement(element, 'click');
+}
+export async function moveToElement(element) {
+    return sendMouseToMiddleOfElement(element, 'move');
+}

package/dist/test-web/element-test-focus.d.ts

@@ -0,0 +1 @@
+export declare function focusElement(element: Element, maxAttemptCount?: number): Promise<void>;

package/dist/test-web/element-test-focus.js

@@ -0,0 +1,17 @@
+import { assert } from '@augment-vir/assert';
+import { clickElement } from './click-element.js';
+import { waitForAnimationFrame } from './symlinked/animation-frame.js';
+import { isElementFocused } from './symlinked/element-focus.js';
+export async function focusElement(element, maxAttemptCount = 20) {
+    let attempts = 0;
+    while (!isElementFocused(element) && attempts < maxAttemptCount) {
+        ++attempts;
+        if (!isElementFocused(element)) {
+            await clickElement(element);
+        }
+        if (!isElementFocused(element)) {
+            await waitForAnimationFrame();
+        }
+    }
+    assert.isBelow(attempts, maxAttemptCount, `Tried ${maxAttemptCount} times to focus the given input element.`);
+}

package/dist/test-web/open-wc-exports.d.ts

@@ -0,0 +1 @@
+export { fixtureCleanup as cleanupFixture, fixture as renderFixture } from '@open-wc/testing-helpers';

package/dist/test-web/open-wc-exports.js

@@ -0,0 +1 @@
+export { fixtureCleanup as cleanupFixture, fixture as renderFixture } from '@open-wc/testing-helpers';

package/dist/test-web/symlinked/animation-frame.d.ts

@@ -0,0 +1 @@
+export declare function waitForAnimationFrame(frameCount?: number): Promise<void>;

package/dist/test-web/symlinked/animation-frame.js

@@ -0,0 +1,17 @@
+import { DeferredPromise } from '@augment-vir/common';
+export async function waitForAnimationFrame(frameCount = 1) {
+    const deferredPromise = new DeferredPromise();
+    function requestNextFrame() {
+        requestAnimationFrame(() => {
+            frameCount--;
+            if (frameCount) {
+                requestNextFrame();
+            }
+            else {
+                deferredPromise.resolve();
+            }
+        });
+    }
+    requestNextFrame();
+    return deferredPromise.promise;
+}

package/dist/test-web/symlinked/element-focus.d.ts

@@ -0,0 +1 @@
+export declare function isElementFocused(element: Element): boolean;

package/dist/test-web/symlinked/element-focus.js

@@ -0,0 +1,3 @@
+export function isElementFocused(element) {
+    return element.matches(':focus');
+}

package/dist/test-web/symlinked/element-position.d.ts

@@ -0,0 +1,5 @@
+import type { Coords } from '@augment-vir/common';
+export declare function checkIfEntirelyInScrollView(element: Element): Promise<unknown>;
+export declare function checkIfInScrollView(element: Element, ratio: number): Promise<unknown>;
+export declare function getCenterOfElement(element: Element): Coords;
+export declare function appendPositionDebugDiv(position: Coords): HTMLDivElement;

package/dist/test-web/symlinked/element-position.js

@@ -0,0 +1,34 @@
+import { assert } from '@augment-vir/assert';
+export async function checkIfEntirelyInScrollView(element) {
+    return checkIfInScrollView(element, 1);
+}
+export async function checkIfInScrollView(element, ratio) {
+    return new Promise((resolve) => {
+        const observer = new IntersectionObserver((entries, observerItself) => {
+            assert.isLengthAtLeast(entries, 1);
+            observerItself.disconnect();
+            resolve(entries[0].intersectionRatio >= ratio);
+        });
+        observer.observe(element);
+    });
+}
+export function getCenterOfElement(element) {
+    const rect = element.getBoundingClientRect();
+    return {
+        x: Math.floor((rect.left + rect.right) / 2),
+        y: Math.floor((rect.bottom + rect.top) / 2),
+    };
+}
+export function appendPositionDebugDiv(position) {
+    const div = document.createElement('div');
+    div.classList.add('debug');
+    div.style.backgroundColor = 'blue';
+    div.style.height = '10px';
+    div.style.left = `${position.x}px`;
+    div.style.position = 'absolute';
+    div.style.top = `${position.y}px`;
+    div.style.width = '10px';
+    div.style.zIndex = '9999';
+    document.body.append(div);
+    return div;
+}

package/dist/test-web/type-into-element.d.ts

@@ -0,0 +1,3 @@
+export declare function typeString(input: string): Promise<void>;
+export declare function typeStringIntoElement(input: string, inputElement: Readonly<HTMLInputElement>): Promise<void>;
+export declare function deleteAllTextInInput(inputElement: Readonly<HTMLInputElement>): Promise<void>;

package/dist/test-web/type-into-element.js

@@ -0,0 +1,30 @@
+import { sendKeys } from '@web/test-runner-commands';
+import { focusElement } from './element-test-focus.js';
+export async function typeString(input) {
+    return await sendKeys({
+        type: input,
+    });
+}
+export async function typeStringIntoElement(input, inputElement) {
+    await focusElement(inputElement);
+    await typeString(input);
+}
+export async function deleteAllTextInInput(inputElement) {
+    const lastValue = inputElement.value;
+    if (lastValue) {
+        await focusElement(inputElement);
+        await sendKeys({
+            press: 'Delete',
+        });
+        await sendKeys({
+            press: 'Backspace',
+        });
+        if (inputElement.value === lastValue) {
+            throw new Error(`Input value was not changed at all`);
+        }
+        if (inputElement.value.length >= lastValue.length) {
+            throw new Error(`Input value length was not decreased.`);
+        }
+        await deleteAllTextInInput(inputElement);
+    }
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+    "name": "@augment-vir/test",
+    "version": "30.0.0",
+    "homepage": "https://github.com/electrovir/augment-vir",
+    "bugs": {
+        "url": "https://github.com/electrovir/augment-vir/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/electrovir/augment-vir.git"
+    },
+    "license": "(MIT or CC0 1.0)",
+    "author": {
+        "name": "electrovir",
+        "url": "https://github.com/electrovir"
+    },
+    "type": "module",
+    "main": "dist/index.js",
+    "module": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "compile": "virmator compile",
+        "docs": "virmator docs",
+        "start": "tsx src/index.ts",
+        "test": "concurrently --colors --kill-others-on-fail -c green,blue --names node,web \"npm run test:node\" \"npm run test:web\"",
+        "test:coverage": "npm run test",
+        "test:docs": "virmator docs check",
+        "test:node": "virmator test --no-deps node 'src/augments/universal-testing-suite/**/*.test.ts'",
+        "test:update": "npm test",
+        "test:web": "virmator test --no-deps web 'src/test-web/**/*.test.ts'"
+    },
+    "dependencies": {
+        "@augment-vir/assert": "^30.0.0",
+        "@augment-vir/common": "^30.0.0",
+        "@open-wc/testing-helpers": "^3.0.1",
+        "type-fest": "^4.25.0"
+    },
+    "devDependencies": {
+        "@types/node": "^22.5.0",
+        "@web/dev-server-esbuild": "^1.0.2",
+        "@web/test-runner": "^0.18.3",
+        "@web/test-runner-commands": "^0.9.0",
+        "@web/test-runner-playwright": "^0.11.0",
+        "concurrently": "^8.2.2",
+        "element-vir": "^22.2.2",
+        "istanbul-smart-text-reporter": "^1.1.4",
+        "typescript": "^5.5.4"
+    },
+    "engines": {
+        "node": ">=22"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}