@flemist/simple-utils 2.1.1 → 2.1.3

package/build/common/test/index.d.ts

@@ -0,0 +1 @@
+export * from './match';

package/build/common/test/match/Matcher.d.ts

@@ -0,0 +1,14 @@
+import { MatchResult3 } from './types';
+export type MatcherArgsName<T> = string | ((actual?: T) => string) | null;
+export type MatcherArgs<T> = {
+    name?: MatcherArgsName<T>;
+};
+export declare abstract class Matcher<Actual, Args extends MatcherArgs<any> | null | undefined = any> {
+    protected _args: Args;
+    constructor(args?: Args);
+    set(args: Partial<Args>): this;
+    name(name?: MatcherArgsName<Actual>): this;
+    abstract match(actual: Actual): MatchResult3;
+    protected abstract nameDefault(actual?: Actual): string;
+    toString(actual?: Actual): string;
+}

package/build/common/test/match/check.d.ts

@@ -0,0 +1,9 @@
+import { Expected } from './types';
+import { PromiseOrValue } from '@flemist/async-utils';
+export declare class CheckError extends Error {
+    constructor(message: string);
+}
+export declare function check<T>(actual: T): (expected: Expected<T>, onError?: (error: Error) => void) => void;
+export declare function checkFunc<T>(func: () => Promise<T>): (expectedValue: Expected<T>, expectedError?: Expected<any>) => Promise<T>;
+export declare function checkFunc<T>(func: () => T): (expectedValue: Expected<T>, expectedError?: Expected<any>) => T;
+export declare function checkFunc<T>(func: () => PromiseOrValue<T>): (expectedValue: Expected<T>, expectedError?: Expected<any>) => PromiseOrValue<T>;

package/build/common/test/match/helpers.d.ts

@@ -0,0 +1,4 @@
+import { Matcher, MatcherArgs } from './Matcher';
+export declare function isMatcher(value: any): value is Matcher<any>;
+export declare function expectedToString(expected: any): string;
+export declare function argsToString(args: MatcherArgs<any> | null | undefined, ...excludeKeys: string[]): string;

package/build/common/test/match/index.d.ts

@@ -0,0 +1,3 @@
+export * from './matchers';
+export { match } from './match';
+export { check } from './check';

package/build/common/test/match/match.d.ts

@@ -0,0 +1,6 @@
+import { Expected, MatchResult, MatchResult3 } from './types';
+export declare function validateMatchResult<T>(_result: MatchResult<T>): MatchResult<T>;
+export declare function createMatchResultError<T>(actual: T, expected: Expected<T>, error: Error): MatchResult<T>;
+export declare function createMatchResultBoolean<T>(actual: T, expected: Expected<T>, result: boolean): MatchResult<T>;
+export declare function createMatchResult<T>(actual: T, expected: Expected<T>, result: MatchResult3): MatchResult<T>;
+export declare function match<T>(actual: T, expected: Expected<T>): MatchResult<T>;

package/build/common/test/match/matchers/MatchInstanceOf.d.ts

@@ -0,0 +1,11 @@
+import { MatchResult3 } from '../types';
+import { Matcher, MatcherArgs } from '../Matcher';
+export type MatchInstanceOfArgs<T> = MatcherArgs<T> & {
+    expected: {
+        new (...args: any[]): T;
+    };
+};
+export declare class MatcherInstanceOf<T> extends Matcher<T, MatchInstanceOfArgs<T>> {
+    match(actual: T): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/MatcherAny.d.ts

@@ -0,0 +1,6 @@
+import { MatchResult3 } from '../types';
+import { Matcher } from '../Matcher';
+export declare class MatcherAny extends Matcher<any> {
+    match(): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/MatcherArray.d.ts

@@ -0,0 +1,12 @@
+import { Expected, MatchResult3 } from '../types';
+import { Matcher, MatcherArgs } from '../Matcher';
+export type MatchArray<T extends any[]> = Array<Expected<T[number]>>;
+export type MatcherArrayArgs<T extends any[]> = MatcherArgs<T> & {
+    expected?: MatchArray<T> | null;
+    matchType?: 'equals' | 'includes';
+    maxReportItems?: number;
+};
+export declare class MatcherArray<T extends any[]> extends Matcher<T, MatcherArrayArgs<T> | null | undefined> {
+    match(actual: T): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/MatcherArrayItem.d.ts

@@ -0,0 +1,10 @@
+import { Expected, MatchResult3 } from '../types';
+import { Matcher, MatcherArgs } from '../Matcher';
+export type MatchArrayItemArgs<T> = MatcherArgs<T[]> & {
+    expected: Expected<T>;
+    maxReportItems?: number;
+};
+export declare class MatcherArrayItem<T> extends Matcher<T[], MatchArrayItemArgs<T>> {
+    match(actual: T[]): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/MatcherConvert.d.ts

@@ -0,0 +1,10 @@
+import { Expected, MatchResult3 } from '../types';
+import { Matcher, MatcherArgs } from '../Matcher';
+export type MatchConvertArgs<T, U> = MatcherArgs<T> & {
+    convert: (actual: T) => U;
+    expected: Expected<U>;
+};
+export declare class MatcherConvert<T, U> extends Matcher<T, MatchConvertArgs<T, U>> {
+    match(actual: T): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/MatcherCustom.d.ts

@@ -0,0 +1,9 @@
+import { MatchResult3 } from '../types';
+import { Matcher, MatcherArgs } from '../Matcher';
+export type MatchCustomArgs<T> = MatcherArgs<T> & {
+    matcher: Matcher<T> | ((actual: T) => MatchResult3);
+};
+export declare class MatcherCustom<T> extends Matcher<T, MatchCustomArgs<T>> {
+    match(actual: T): MatchResult3;
+    nameDefault(actual?: T): string;
+}

package/build/common/test/match/matchers/MatcherFew.d.ts

@@ -0,0 +1,13 @@
+import { Expected, MatchResult3 } from '../types';
+import { Matcher, MatcherArgs } from '../Matcher';
+export type MatchFewArgs<T> = MatcherArgs<T> & {
+    type: 'or' | 'and';
+    expecteds: Array<Expected<T>>;
+    /** If true, then it will not check remains unnecessary expecteds.
+     * So there will be less information in logs especially if you use 'Not' operator */
+    pipe?: boolean | null;
+};
+export declare class MatcherFew<T> extends Matcher<T, MatchFewArgs<T>> {
+    match(actual: T): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/MatcherIn.d.ts

@@ -0,0 +1,12 @@
+import { MatchResult3 } from '../types';
+import { Matcher, MatcherArgs } from '../Matcher';
+export type MatchInArgs<T> = MatcherArgs<T> & {
+    expected: Set<T>;
+};
+export declare class MatcherIn<T> extends Matcher<T, MatchInArgs<T>> {
+    constructor(args: Omit<MatchInArgs<T>, 'expected'> & {
+        expected: Set<T> | Iterable<T>;
+    });
+    match(actual: T): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/MatcherIs.d.ts

@@ -0,0 +1,10 @@
+import { MatchResult3 } from '../types';
+import { Matcher, MatcherArgs } from '../Matcher';
+export type MatchIsArgs<T> = MatcherArgs<T> & {
+    expected: T;
+    nonStrict?: boolean | null;
+};
+export declare class MatcherIs<T> extends Matcher<T, MatchIsArgs<T>> {
+    match(actual: T): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/MatcherNever.d.ts

@@ -0,0 +1,6 @@
+import { MatchResult3 } from '../types';
+import { Matcher } from '../Matcher';
+export declare class MatcherNever extends Matcher<any> {
+    match(): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/MatcherNot.d.ts

@@ -0,0 +1,9 @@
+import { Expected, MatchResult3 } from '../types';
+import { Matcher, MatcherArgs } from '../Matcher';
+export type MatchNotArgs<T> = MatcherArgs<T> & {
+    expected: Expected<T>;
+};
+export declare class MatcherNot<T> extends Matcher<T, MatchNotArgs<T>> {
+    match(actual: T): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/MatcherNumber.d.ts

@@ -0,0 +1,15 @@
+import { MatchResult3 } from '../types';
+import { Matcher, MatcherArgs } from '../Matcher';
+export type MatchNumberArgsRange = MatcherArgs<number> & {
+    min?: number | null;
+    max?: number | null;
+    allowInfinity?: boolean | null;
+    allowNaN?: boolean | null;
+};
+export type MatchNumberArgs = MatchNumberArgsRange & {
+    float?: boolean | null;
+};
+export declare class MatcherNumber extends Matcher<number, MatchNumberArgs | undefined | null> {
+    match(actual: number): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/MatcherObject.d.ts

@@ -0,0 +1,14 @@
+import { Expected, MatchResult3 } from '../types';
+import { Matcher, MatcherArgs } from '../Matcher';
+export type MatchObject<T> = {
+    [K in keyof T]: Expected<T[K]>;
+};
+export type MatcherObjectArgs<T> = MatcherArgs<T> & {
+    expected?: MatchObject<T> | null;
+    ignoreExtraKeys?: boolean;
+    maxReportItems?: number;
+};
+export declare class MatcherObject<T> extends Matcher<T, MatcherObjectArgs<T> | undefined | null> {
+    match(actual: T): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/MatcherObjectEntry.d.ts

@@ -0,0 +1,11 @@
+import { Expected, MatchResult3 } from '../types';
+import { Matcher, MatcherArgs } from '../Matcher';
+export type MatchObjectEntry<T> = Expected<[keyof T, T[keyof T]]>;
+export type MatcherObjectEntryArgs<T> = MatcherArgs<T> & {
+    expected?: MatchObjectEntry<T> | null;
+    maxReportItems?: number;
+};
+export declare class MatcherObjectEntry<T> extends Matcher<T, MatcherObjectEntryArgs<T> | undefined | null> {
+    match(actual: T): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/MatcherRef.d.ts

@@ -0,0 +1,10 @@
+import { Matcher } from '../Matcher';
+import { Expected, MatchResult3 } from '../types';
+export declare class MatcherRef<T> extends Matcher<T> {
+    private _hasExpected;
+    private _expected;
+    get expected(): Expected<T>;
+    set expected(value: Expected<T>);
+    match(actual: T): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/MatcherString.d.ts

@@ -0,0 +1,10 @@
+import { MatchResult3 } from '../types';
+import { Matcher, MatcherArgs } from '../Matcher';
+export type MatchStringPattern = RegExp | ((actual: string) => MatchResult3);
+export type MatchStringArgs = MatcherArgs<string> & {
+    pattern?: MatchStringPattern | null;
+};
+export declare class MatcherString extends Matcher<string, MatchStringArgs | undefined | null> {
+    match(actual: string): MatchResult3;
+    nameDefault(): string;
+}

package/build/common/test/match/matchers/constants.d.ts

@@ -0,0 +1 @@
+export declare const MAX_REPORT_ITEMS_DEFAULT = 10;

package/build/common/test/match/matchers/index.d.ts

@@ -0,0 +1 @@
+export * from './matchers';

package/build/common/test/match/matchers/matchers.d.ts

@@ -0,0 +1,92 @@
+import { MatchArray, MatcherArray } from './MatcherArray';
+import { MatcherAny } from './MatcherAny';
+import { Expected, MatchResult3 } from '../types';
+import { MatcherConvert } from './MatcherConvert';
+import { MatcherIs } from './MatcherIs';
+import { MatcherNumber, MatchNumberArgs, MatchNumberArgsRange } from './MatcherNumber';
+import { MatcherObject, MatchObject } from './MatcherObject';
+import { MatcherString, MatchStringPattern } from './MatcherString';
+import { MatcherInstanceOf } from './MatchInstanceOf';
+import { MatcherIn } from './MatcherIn';
+import { MatcherFew } from './MatcherFew';
+import { MatcherCustom } from './MatcherCustom';
+import { MatcherNot } from './MatcherNot';
+import { Matcher, MatcherArgsName } from '../Matcher';
+import { MatcherNever } from './MatcherNever';
+import { ValueState } from '@flemist/async-utils';
+import { MatcherObjectEntry } from './MatcherObjectEntry';
+import { MatcherRef } from './MatcherRef';
+export declare function matchArray<T extends any[]>(expected?: MatchArray<T> | null): MatcherArray<T>;
+export declare function matchArrayIncludes<T extends any[]>(expected: MatchArray<T>): MatcherArray<T>;
+export declare function matchAny(): MatcherAny;
+export declare function matchRef<T>(): MatcherRef<T>;
+export declare function matchNever(name?: MatcherArgsName<any> | null): MatcherNever;
+/** Check array length and then check each item with expected */
+export declare function matchArrayItem<T>(expectedLength: Expected<number> | MatchIntArgs | null | undefined, expected: Expected<T>): Matcher<T[]>;
+export declare function matchConvert<T, U>(name: MatcherArgsName<T>, convert: (actual: T) => U, expected: Expected<U>): MatcherConvert<T, U>;
+export declare function matchIsNonStrict<T>(expected: T): MatcherIs<T>;
+export declare function matchIs<T>(expected: T): MatcherIs<T>;
+export declare function matchNumber(args?: MatchNumberArgs | null): MatcherNumber;
+export type MatchIntArgs = MatchNumberArgsRange;
+export declare function matchInt(args?: MatchIntArgs | null): MatcherNumber;
+export type MatchFloatArgs = MatchNumberArgsRange;
+export declare function matchFloat(args?: MatchFloatArgs | null): MatcherNumber;
+export declare function matchObject<T>(expected?: MatchObject<T> | null): MatcherObject<T>;
+export declare function matchDeep<T>(expected?: Expected<T> | null, toExpected?: <T>(value: T, key: string | number | null) => Expected<T> | null, key?: string | number | null): any;
+export declare function matchObjectPartial<T>(expected?: MatchObject<Partial<T>> | null): MatcherObject<T>;
+export declare function matchString(pattern?: MatchStringPattern | null): MatcherString;
+export declare function matchInstanceOf<T>(expected: {
+    new (...args: any[]): T;
+}): MatcherInstanceOf<T>;
+export declare function matchTypeOf(expected: Expected<string>): MatcherConvert<any, string>;
+export declare function matchConstructor<T>(expected: {
+    new (...args: any[]): T;
+}): MatcherConvert<T, Function>;
+export declare function matchBoolean(): MatcherConvert<any, string>;
+export declare function matchNullish(): MatcherIs<any>;
+export declare function matchNotNullish(): MatcherNot<any>;
+export declare function matchOr<T>(...expecteds: Array<Expected<T>>): MatcherFew<T>;
+export declare function matchAnd<T>(...expecteds: Array<Expected<T>>): MatcherFew<T>;
+export declare function matchOrPipe<T>(...expecteds: Array<Expected<T>>): MatcherFew<T>;
+export declare function matchAndPipe<T>(...expecteds: Array<Expected<T>>): MatcherFew<T>;
+export declare function matchOptional<T>(expected: Expected<T>, required?: null | boolean): Expected<T>;
+export declare function matchArrayLength(args?: MatchIntArgs | Expected<number> | null | undefined): MatcherFew<any[]>;
+export declare function matchStringLength(args?: MatchIntArgs | Expected<number> | null | undefined): MatcherFew<string>;
+export declare function matchObjectWith<T>(matcher: Matcher<T>): MatcherFew<T>;
+/** Check if it is an array and then check with matcher */
+export declare function matchArrayWith<T extends any[]>(matcher: Matcher<T[]>): MatcherFew<T>;
+export declare function matchObjectKeys<T extends object>(expected: Expected<Array<keyof T>>): MatcherFew<T>;
+export declare function matchObjectValues<T extends object>(expected: Expected<Array<T[keyof T]>>): MatcherFew<T>;
+export declare function matchObjectEntries<T extends object>(expected: Expected<Array<[keyof T, T[keyof T]]>>): MatcherFew<T>;
+export declare function matchObjectEntry<T extends object>(expected: Expected<[keyof T, T[keyof T]]>): MatcherObjectEntry<T>;
+export declare function matchObjectKey<T extends object>(expected: Expected<keyof T>): MatcherObjectEntry<T>;
+export declare function matchObjectValue<T extends object>(expected: Expected<T[keyof T]>): MatcherObjectEntry<T>;
+export declare function matchObjectKeyValue<T extends object>(expectedKey: Expected<keyof T>, expectedValue: Expected<T[keyof T]>): MatcherObjectEntry<T>;
+export declare function matchObjectKeysNotNull<T extends object>(expected: Expected<Array<keyof T>>): MatcherFew<T>;
+export declare function matchIn<T>(expected: Set<T> | Iterable<T>): MatcherIn<T>;
+export declare function matchEnum<T>(enumObject: {
+    [key: string]: T;
+}): MatcherIn<T>;
+export declare function matchCustom<T>(name: MatcherArgsName<T>, matcher: Matcher<T> | ((actual: T) => MatchResult3)): MatcherCustom<T>;
+export type MatchRangeValueOptions = {
+    min?: number | null;
+    max?: number | null;
+    optional?: boolean | null;
+    float?: boolean | null;
+};
+export type MatchRangeOptions = {
+    common?: null | MatchRangeValueOptions;
+    from?: null | MatchRangeValueOptions;
+    to?: null | MatchRangeValueOptions;
+};
+export declare function matchIntDate(options?: MatchIntArgs): Matcher<number>;
+export declare function matchRange(options?: MatchRangeOptions | null): MatcherFew<any[]>;
+export declare function matchRangeDate(args?: MatchRangeOptions | null): MatcherFew<any[]>;
+export declare function matchNot<T>(expected: Expected<T>): MatcherNot<T>;
+export declare function matchUuid(): Matcher<string>;
+export declare function matchValueState<T>(args: MatchObject<Partial<ValueState<T>>>): MatcherObject<ValueState<T>>;
+export declare function matchArrayBuffer<T extends {
+    readonly byteLength: number;
+}>(expected?: {
+    readonly byteLength: number;
+} | string | null): Matcher<T>;

package/build/common/test/match/report.d.ts

@@ -0,0 +1,5 @@
+import { MatchResult, MatchResultNested } from './types';
+export declare function filterMatchResultNested(matchResultNested: MatchResultNested, inverseResult: boolean): MatchResultNested | null;
+export declare function filterMatchResult(matchResult: MatchResult<any>, inverseResult: boolean): MatchResult<any> | null;
+export declare function matchResultNestedToString(matchResultNested: MatchResultNested, indent: string): string;
+export declare function matchResultToString(matchResult: MatchResult<any>, indent: string): any;

package/build/common/test/match/types.d.ts

@@ -0,0 +1,24 @@
+import { Matcher } from './Matcher';
+export type Expected<T> = T | Matcher<T>;
+export type MatchResultNested = {
+    actualKey?: null | string | number;
+    expectedKey?: null | string | number;
+    result: MatchResult<any>;
+};
+export type MatchResult<T> = {
+    actual: T;
+    expected: Expected<T>;
+    result: boolean;
+    cause?: null | string;
+    nested?: null | MatchResultNested[];
+    error?: null | Error;
+};
+export interface MatchResult2 {
+    result: boolean;
+    cause?: string | null;
+    nested?: MatchResultNested[] | null;
+}
+export type MatchResult3 = boolean | string | MatchResult2;
+export declare class MatchInternalError extends Error {
+    constructor(message: string);
+}

package/build/node/test/e2e/check/checkPageHttpErrors.d.ts

@@ -0,0 +1,25 @@
+import { Page } from 'playwright';
+export type RegExpRule = {
+    value: boolean;
+    pattern: RegExp;
+};
+export type UrlWithError = {
+    url: URL;
+    error: string;
+};
+export type GetPageHttpErrorsTimeouts = {
+    downloadInternal?: null | number;
+    downloadExternal?: null | number;
+    total?: null | number;
+};
+export type GetPageHttpErrorsArgs = {
+    page: Page;
+    urlFilters?: RegExpRule[] | null;
+    timeouts?: null | GetPageHttpErrorsTimeouts;
+};
+export declare function getPageHttpErrors({ page, urlFilters, timeouts, }: GetPageHttpErrorsArgs): Promise<UrlWithError[] | undefined | null>;
+export declare function checkPageHttpErrors({ page, urlFilters, errorFilter, }: {
+    page: Page;
+    urlFilters?: RegExpRule[] | null;
+    errorFilter?: ((args: UrlWithError) => boolean) | null;
+}): Promise<void>;

package/build/node/test/e2e/check/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './checkPageHttpErrors';
+export * from './subscribeJsErrors';

package/build/node/test/e2e/check/subscribeJsErrors.d.ts

@@ -0,0 +1,10 @@
+import { Page } from 'playwright';
+import { OnError } from './types';
+export declare function subscribeJsErrors({ page, filter, onError, }: {
+    page: Page;
+    filter?: ((args: {
+        url: URL;
+        error: string;
+    }) => boolean) | null;
+    onError: OnError;
+}): Promise<void>;

package/build/node/test/e2e/check/types.d.ts

@@ -0,0 +1 @@
+export type OnError = (error: Error) => void;

package/build/node/test/e2e/index.d.ts

@@ -0,0 +1,3 @@
+export * from './check';
+export * from './setPlaywrightPriorityLow';
+export * from './test';

package/build/node/test/e2e/setPlaywrightPriorityLow.d.ts

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

package/build/node/test/e2e/test/delayOnError.d.ts

@@ -0,0 +1,3 @@
+export declare function delayOnErrorSet(time: number): void;
+export declare function delayOnErrorCall(): Promise<void> | undefined;
+export declare function delayOnErrorWait(): Promise<void> | null;

package/build/node/test/e2e/test/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './delayOnError';
+export * from './initPage';
+export * from './testPage';
+export * from './useBrowser';
+export * from './useBrowserContext';

package/build/node/test/e2e/test/initPage.d.ts

@@ -0,0 +1,25 @@
+import { RegExpRule, UrlWithError } from '../check/checkPageHttpErrors';
+import { Page } from 'playwright';
+import { IAbortSignalFast } from '@flemist/abort-controller-fast';
+export type Filters = {
+    js?: {
+        filter?: null | ((args: {
+            url: URL;
+            error: string;
+        }) => boolean);
+    } | null;
+    http?: {
+        urlFilters?: RegExpRule[] | null;
+        errorFilter?: ((args: UrlWithError) => boolean) | null;
+    } | null;
+};
+export declare function initPage(args: {
+    page: Page;
+    /** for reporting only */
+    pageFilePath?: null | string;
+    abortSignal?: null | IAbortSignalFast;
+    filters?: null | Filters;
+}): Promise<{
+    abortSignal: IAbortSignalFast;
+    checkErrors: () => Promise<void>;
+}>;

package/build/node/test/e2e/test/testPage.d.ts

@@ -0,0 +1,17 @@
+import { TestFuncArgs } from './types';
+import { Filters } from './initPage';
+import { Page } from 'playwright';
+import { IAbortSignalFast } from '@flemist/abort-controller-fast';
+export type TestPageFuncArgs = TestFuncArgs & {
+    checkErrors: () => Promise<void>;
+};
+export type TestPageFunc = (args: TestPageFuncArgs) => Promise<void>;
+export type TestPageArgs = {
+    page: Page;
+    abortSignal?: null | IAbortSignalFast;
+    filters?: null | Filters;
+    func: TestPageFunc;
+    /** for reporting only */
+    pageFilePath?: null | string;
+};
+export declare function testPage({ page, abortSignal: _abortSignal, filters, func, pageFilePath, }: TestPageArgs): Promise<void>;

package/build/node/test/e2e/test/types.d.ts

@@ -0,0 +1,7 @@
+import { Page } from 'playwright';
+import { IAbortSignalFast } from '@flemist/abort-controller-fast';
+export type TestFuncArgs = {
+    page: Page;
+    abortSignal: IAbortSignalFast;
+};
+export type TestFunc = (args: TestFuncArgs) => Promise<void>;

package/build/node/test/e2e/test/useBrowser.d.ts

@@ -0,0 +1,5 @@
+import { Browser, BrowserType, LaunchOptions } from 'playwright';
+export declare function useBrowser<T = void>({ browserType, options, }: {
+    browserType: BrowserType;
+    options?: null | LaunchOptions;
+}): (func: (browser: Browser) => Promise<T>) => Promise<T>;

package/build/node/test/e2e/test/useBrowserContext.d.ts

@@ -0,0 +1,5 @@
+import { Browser, BrowserContext, BrowserContextOptions } from 'playwright';
+export declare function useBrowserContext<T = void>({ browser, options, }: {
+    browser: Browser;
+    options?: null | BrowserContextOptions;
+}): (func: (context: BrowserContext) => Promise<T>) => Promise<T>;

package/build/node/test/index.d.ts

@@ -0,0 +1,2 @@
+export * from './e2e';
+export * from './refactor';

package/build/node/test/refactor/createPagesElementsChangesTest.d.ts

@@ -0,0 +1,11 @@
+import { PagesElementsChangesTest, TPseudoStateConfig, TGetAllElementsFilters } from './types';
+export type ObjectTransform = (value: any, keyOrIndex: string | number | null | undefined, parent: any | null | undefined, transform: ObjectTransform) => any;
+export declare const objectTransform: ObjectTransform;
+export declare function createPagesElementsChangesTest({ actualResultFile, expectedResultFile, diffResultFile, filters, transform, pseudoStates, }: {
+    actualResultFile: string;
+    expectedResultFile: string;
+    diffResultFile?: string;
+    filters?: TGetAllElementsFilters;
+    transform?: null | ObjectTransform;
+    pseudoStates?: null | TPseudoStateConfig[];
+}): PagesElementsChangesTest;

package/build/node/test/refactor/forcePseudoClasses.d.ts

@@ -0,0 +1,5 @@
+import { CDPSession, Page } from 'playwright';
+export declare function createCDPSession(page: Page): Promise<CDPSession>;
+export declare function destroyCDPSession(cdp: CDPSession): Promise<void>;
+export declare function usingCDPSession<Result>(page: Page, func: (cdp: CDPSession) => Promise<Result>): Promise<Result>;
+export declare function forcePseudoClasses(cdp: CDPSession, pseudoClasses: string[]): Promise<void>;

package/build/node/test/refactor/getAllElements.d.ts

@@ -0,0 +1,2 @@
+import { TGetAllElementsArgs } from './types';
+export declare function getAllElements(args: TGetAllElementsArgs): never;

package/build/node/test/refactor/getElementsStyleDiff.d.ts

@@ -0,0 +1,2 @@
+import { TElement } from './types';
+export declare function getElementsStyleDiff(base: TElement, state: TElement): TElement | null;

package/build/node/test/refactor/getObjectsDiff.d.ts

@@ -0,0 +1,6 @@
+export declare const DIFF_OLD = "-";
+export declare const DIFF_NEW = "+";
+export declare function getObjectsDiff(valueOld: any, valueNew: any, handleDiff?: null | ((valueOld: any, valueNew: any, diffs: any) => any)): any[] | Record<string, any> | {
+    "-": any;
+    "+": any;
+} | null;

package/build/node/test/refactor/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './createPagesElementsChangesTest';
+export * from './forcePseudoClasses';
+export * from './getAllElements';
+export * from './getElementsStyleDiff';
+export * from './getObjectsDiff';
+export * from './loadSaveJson';

package/build/node/test/refactor/loadSaveJson.d.ts

@@ -0,0 +1,2 @@
+export declare function saveJson(filePath: string, json: any): Promise<void>;
+export declare function loadJson(filePath: string): Promise<any>;

package/build/node/test/refactor/types.d.ts

@@ -0,0 +1,72 @@
+import { Page } from 'playwright';
+export type TNameValue = {
+    [key: string]: string;
+};
+export type TStyle = {
+    _: TNameValue;
+    before: TNameValue;
+    after: TNameValue;
+};
+export type TElement = {
+    tag: string;
+    selector: string;
+    classes: string[] | null | undefined;
+    attrs: TNameValue | null | undefined;
+    style: TStyle | null | undefined;
+    childs: TElement[] | null | undefined;
+};
+export type TGetAllElementsFilters = {
+    excludeAttrs?: string[];
+    /** Fix attribute values by replacing matching patterns; useful for removing generated hashes */
+    fixAttrs?: TFixPattern[];
+    /** Fix style values by replacing matching patterns in CSS property values */
+    fixStyles?: TFixPattern[];
+    /** Exclude matching classes from the `classes` array */
+    excludeClasses?: RegExp;
+    /** Exclude matching id from comparison data */
+    excludeIds?: RegExp;
+    /** Exclude matching classes from displayed `selector` in diffs */
+    excludeSelectorClasses?: RegExp;
+    /** Exclude matching id  from displayed `selector` in diffs */
+    excludeSelectorIds?: RegExp;
+    /** Fix tag values by replacing matching patterns */
+    fixTags?: TReplacePattern[];
+    excludeStyles?: string[];
+    excludeSelectors?: string[];
+};
+export type TPseudoStateConfig = {
+    states: string[];
+    delay?: null | number;
+};
+export type TReplacePattern = {
+    search: RegExp;
+    replace: string;
+};
+export type TFixPattern = TReplacePattern & {
+    name: RegExp;
+};
+export type TGetAllElementsArgs = {
+    defaultStyle?: null | TStyle;
+    shouldEqualResult?: null | TElement;
+    filters?: null | TGetAllElementsFilters;
+};
+export type PagesElementsChangesHandlePage = (args: {
+    page: Page;
+    testId: string;
+    url: URL;
+    stateId: string;
+    filters?: TGetAllElementsFilters;
+}) => Promise<void>;
+export type PagesElementsChangesTest = {
+    init(page: Page): Promise<void>;
+    handlePage: PagesElementsChangesHandlePage;
+    end({ checkExistUrlsOnly }: {
+        checkExistUrlsOnly: boolean;
+    }): Promise<{
+        [testId: string]: {
+            [url: string]: {
+                [stateId: string]: TElement;
+            };
+        };
+    }>;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flemist/simple-utils",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "Simple simple utils",
   "sideEffects": false,
   "types": "build/common/index.d.ts",
@@ -65,7 +65,7 @@
   },
   "scripts": {
     "========================= install =========================": "",
-    "prepublishOnly": "run-p audit lint build test:all",
+    "_prepublishOnly": "run-p audit lint build test:all && npm login",
     "prepare": "node .husky/install.mjs",
     "install:playwright": "pnpm exec playwright install --with-deps",
     "========================= deploy =========================": "",