graffhyrum

These files are an illustration of the benefits available in playwright test projects. It leverages parallelization and composed fixtures to create a matrix of tests for different combinations of test environments, browsers, and resolutions. The following is a brief description of the files in their execution order:

1. playwright.config.ts: This is the entry point for the Playwright tests. It defines the configuration for the tests and uses the getProjects function to generate a matrix of tests for different combinations of environments, browsers, and resolutions.

2. getProjects.ts: This file defines a function getProjects that generates a matrix of tests for different combinations of environments, browsers, and resolutions. The function can be customized with specific environments, browsers, and resolutions to test.

3. params.ts: This file defines several constants and types related to the testable environments, browsers, and resolutions. It also defines the types TestableEnvironment, `Testabl

graffhyrum

Summary

The sendTabUntilFocused function is an asynchronous function in TypeScript that simulates the pressing of the 'Tab' key until a specific element on the webpage is focused. This function is useful in automated testing scenarios where you need to simulate user interactions with a webpage.

Signature

async function sendTabUntilFocused(page: Page, selector: ReturnType<typeof page.locator>): Promise<void>

Parameters

• page: An instance of the Page class from the Playwright library, representing a single tab in a browser.

graffhyrum

retryUntilSuccess Function

The retryUntilSuccess function is a utility function that allows you to retry a given function until it succeeds or until a maximum number of attempts has been reached.

Signature

function retryUntilSuccess<Fn extends RetryFunction>(f: Fn, n: number, ...args: Parameters<Fn>): boolean

graffhyrum

/**
 * Type definition for a function that creates an API method.
 * This function takes an options object with a url and a method type.
 * It returns a function that takes an input object and returns a Promise of an output object.
 *
 * @template TInput - An object type that extends Record<string, string>.
 * @template TOutput - The type of the output object.
 *
 * @param {Object} options - The options for the API method.
 * @param {string} options.url - The URL for the API method.

graffhyrum

/**
 * This utility type `Prefixed` is used to prefix the keys of a given object type.
 * It takes two type parameters:
 * - `Prefix` which is a string that will be used as the prefix.
 * - `Base` which is the object type whose keys will be prefixed.
 *
 * The resulting type will have the same values as the `Base` type, but the keys will be prefixed with the `Prefix`.
 *
 * @template Prefix - The prefix to be added to the keys of the `Base` type.
 * @template Base - The base object type whose keys will be prefixed.

graffhyrum

The provided TypeScript code defines a utility type RecursivePartial. This type is used to create a version of an existing type, but with all of its properties (and their nested properties) made optional and able to be partially provided.

The RecursivePartial type is defined as a mapped type that iterates over all properties (Prop) of a given type (Type):

export type RecursivePartial<Type> = {
  [Prop in keyof Type]?: ...
};

graffhyrum

The provided TypeScript code defines a utility type OneOfType that ensures an object can only have one property from the provided type. This is achieved using TypeScript's conditional and mapped types.

The OneOfType type is defined as follows:

export type OneOfType<T> = ValueOf<OneOfByKey<T>>;

Here, OneOfType is a mapped type that transforms an object type T into a type that allows only one property from T to be present at a time. It uses two helper types OneOfByKey and ValueOf.

graffhyrum

The TypeScript code snippet provided is a utility for working with objects in a type-safe manner. It defines a type Entries and a function getEntries.

The Entries type is a mapped type that transforms the properties of an object type T into an array of tuples. Each tuple contains the property key as its first element and the corresponding property value as its second element.

export type Entries<T> = {
  [K in keyof T]-?: [K, T[K]];
}[keyof T][];

graffhyrum

Branded Types

A "Branded" type is a type that is a subtype of the original type, but has a unique literal value in a common field (the brand). This allows us to define types that are more specific than the original type, but are still compatible with it. For example, we have the type EmailAddress, which is a string that is guaranteed to be a valid email address.

Branded types can only be created by calling the brand function, which takes a value of the original type and returns a value of the branded type.

Usage

graffhyrum

# Script to parse FFXIV text logs, returns a transcript for all logs that include any two characters.
# script will prompt for:
#   the name of the file (do not include extension, file should be in the same directory as the script)
#   The first name to look for
#   The second name to look for
$file = Read-Host -Prompt "Enter the txt file name:"
$nameOfUser = Read-Host -Prompt "Paste or enter the first character's name:"
$personName = Read-Host -Prompt "Paste or enter the second character's name:"
$input_path = $PSScriptRoot + "\" + $file + '.txt'
$output_file = $PSScriptRoot + "\" + $file + "_" + $personName +  '_parsedLog2.txt'