@amazon/vinyl-util 1.0.0

package/dist/browserTestUtil/types/current/async/createCallbackTimingTest.js

@@ -0,0 +1,57 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { marbleTest } from './marble';
+var createSpy = jasmine.createSpy;
+/**
+ * Creates a marble test for callback timing.
+ * This provides an easy way to test callback timing, for example a debounce or throttle function.
+ *
+ * The returned function takes an input string where dashes represent a wait of 1 second, and x's represent
+ * invoking the function returned by wrapCallback. The resolved string will be the timing of when the inner function is
+ * invoked.
+ * An x does not represent passage of time. For example a marble diagram of x-xx-x represents execution at:
+ * 0s, 1s, 1s, 2s
+ *
+ * @param clock
+ * @param wrapCallback
+ */
+export function createCallbackTimingTest(clock, wrapCallback) {
+    return marbleTest(() => {
+        clock.mockDate(new Date(0));
+        let _out = '';
+        let lastTimeMs = 0;
+        const writeTime = () => {
+            const nowMs = Date.now();
+            _out += '-'.repeat((nowMs - lastTimeMs) / 1000);
+            lastTimeMs = nowMs;
+        };
+        const spy = createSpy('inner').and.callFake(() => {
+            writeTime();
+            _out += 'x';
+        });
+        const throttled = wrapCallback(spy);
+        return {
+            spy,
+            throttled,
+            get out() {
+                return _out;
+            },
+        };
+    }, {
+        '-': () => {
+            return clock.tick(1);
+        },
+        x: (test) => {
+            test.throttled();
+        },
+    }, async (o) => {
+        // Flush any pending timeouts up to 10s in the future, ticking in 1s increments
+        // in order to get correct mock time resolution:
+        for (let i = 0; i < 10; i++) {
+            await clock.tick(1);
+        }
+        return o.out;
+    });
+}

package/dist/browserTestUtil/types/current/async/marble.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates a marble test, returning a function (input: string) => string where the input is a
+ * sequence of characters, each character mapping to the legend, and the output a string
+ * produced by the output generator.
+ *
+ * @param init
+ * @param legend An object whose keys are characters, and the values are functions to invoke when
+ * the character is found in the input string.
+ * @param output A method to invoke at the end of the actions to return the output sequence.
+ */
+export declare function marbleTest<T>(init: () => Promise<T> | T, legend: Readonly<Record<string, ((test: T) => Promise<void> | void) | undefined>>, output: (test: T) => Promise<string> | string): (input: string) => Promise<string>;
+//# sourceMappingURL=marble.d.ts.map

package/dist/browserTestUtil/types/current/async/marble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marble.d.ts","sourceRoot":"","sources":["../../../../../test/browserTestUtil/async/marble.ts"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,CAAC,EACxB,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAC1B,MAAM,EAAE,QAAQ,CACZ,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAC,CAClE,EACD,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,GAC9C,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAWpC"}

package/dist/browserTestUtil/types/current/async/marble.js

@@ -0,0 +1,27 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Creates a marble test, returning a function (input: string) => string where the input is a
+ * sequence of characters, each character mapping to the legend, and the output a string
+ * produced by the output generator.
+ *
+ * @param init
+ * @param legend An object whose keys are characters, and the values are functions to invoke when
+ * the character is found in the input string.
+ * @param output A method to invoke at the end of the actions to return the output sequence.
+ */
+export function marbleTest(init, legend, output) {
+    return async (input) => {
+        const test = await init();
+        for (let i = 0; i < input.length; i++) {
+            const char = input[i];
+            const action = legend[char];
+            if (!action)
+                throw new Error(`Unknown marble: '${char}'`);
+            await action(test);
+        }
+        return output(test);
+    };
+}

package/dist/browserTestUtil/types/current/benchmark/Benchmark.d.ts

@@ -0,0 +1,90 @@
+export interface BenchMarkOptions {
+    /**
+     * The amount of time to run the executor before beginning measurement (in seconds).
+     */
+    readonly warmupTime: number;
+    /**
+     * When time has elapsed past this duration during a cycle (in seconds), there will be no
+     * operations.
+     * The cycle will end when `maxCycleDuration` has been reached.
+     */
+    readonly maxCycleDuration: number;
+    /**
+     * The number of trials to run.
+     */
+    readonly cycles: number;
+}
+export interface CycleResults {
+    /**
+     * The number of seconds the cycle ran.
+     */
+    readonly duration: number;
+    /**
+     * The number of completed executions.
+     */
+    readonly ops: number;
+}
+export declare class BenchmarkRunResults {
+    readonly name: string;
+    readonly cycleResults: number[];
+    private _totalSamples;
+    get totalSamples(): number;
+    get cycleResultsNoOutliers(): number[];
+    /**
+     * Returns the mean ops per second minus outliers of greater than 3 standard deviations.
+     */
+    get meanOpsPerSec(): number;
+    get standardDeviation(): number;
+    get variance(): number;
+    /**
+     * Returns the mean ops / s ± variance % as a string.
+     */
+    get meanOpsStr(): string;
+    constructor(name: string);
+    add(cycle: CycleResults): void;
+    toString(): string;
+}
+export declare class RunResultsComparison {
+    readonly name: string;
+    /**
+     * Sorted by median ops/s from slowest to fastest.
+     */
+    readonly results: BenchmarkRunResults[];
+    constructor(name: string, results: BenchmarkRunResults[]);
+    logToTable(): void;
+    runComparisonToString(run: BenchmarkRunResults): string;
+}
+export declare function compareResults(name: string, ...results: BenchmarkRunResults[]): RunResultsComparison;
+export declare class Benchmark {
+    readonly name: string;
+    readonly executor: () => any;
+    private static semaphore;
+    private readonly options;
+    /**
+     * Constructs a new Benchmark.
+     *
+     * @param name The name of the benchmark, to be used when logging.
+     * @param executor The method to execute and measure. If this method returns a promise, the
+     * promise will be awaited. The executor should either always return a promise, or never.
+     * @param options Optional configuration for the benchmark.
+     */
+    constructor(name: string, executor: () => any, options?: Partial<BenchMarkOptions>);
+    run(): Promise<BenchmarkRunResults>;
+    /**
+     * Runs one cycle. A cycle will repeat the executor approximately `options.maxCycleDuration`
+     * seconds.
+     *
+     * @param isAsync
+     * @return Returns the duration (in seconds) and number of operations the cycle repeated.
+     */
+    private runCycle;
+}
+/**
+ * Creates and runs a benchmark, logging the result.
+ *
+ * @param name
+ * @param executor
+ * @param options
+ */
+export declare function benchmark(name: string, executor: () => any, options?: Partial<BenchMarkOptions>): Promise<BenchmarkRunResults>;
+//# sourceMappingURL=Benchmark.d.ts.map

package/dist/browserTestUtil/types/current/benchmark/Benchmark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Benchmark.d.ts","sourceRoot":"","sources":["../../../../../test/browserTestUtil/benchmark/Benchmark.ts"],"names":[],"mappings":"AA6BA,MAAM,WAAW,gBAAgB;IAC7B;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAE3B;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAA;IAEjC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAC1B;AAED,MAAM,WAAW,YAAY;IACzB;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IAEzB;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;CACvB;AAED,qBAAa,mBAAmB;IA6ChB,QAAQ,CAAC,IAAI,EAAE,MAAM;IA5CjC,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,CAAK;IAEpC,OAAO,CAAC,aAAa,CAAI;IACzB,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,IAAI,sBAAsB,IAAI,MAAM,EAAE,CAOrC;IAED;;OAEG;IACH,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,IAAI,iBAAiB,IAAI,MAAM,CAE9B;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAQvB;gBAEoB,IAAI,EAAE,MAAM;IAEjC,GAAG,CAAC,KAAK,EAAE,YAAY;IAQvB,QAAQ,IAAI,MAAM;CAIrB;AAED,qBAAa,oBAAoB;IAOzB,QAAQ,CAAC,IAAI,EAAE,MAAM;IANzB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,mBAAmB,EAAE,CAAA;gBAG1B,IAAI,EAAE,MAAM,EACrB,OAAO,EAAE,mBAAmB,EAAE;IAOlC,UAAU,IAAI,IAAI;IAyBlB,qBAAqB,CAAC,GAAG,EAAE,mBAAmB,GAAG,MAAM;CAS1D;AAED,wBAAgB,cAAc,CAC1B,IAAI,EAAE,MAAM,EACZ,GAAG,OAAO,EAAE,mBAAmB,EAAE,GAClC,oBAAoB,CAEtB;AAQD,qBAAa,SAAS;IAcd,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG;IAdhC,OAAO,CAAC,MAAM,CAAC,SAAS,CAA4B;IAEpD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAkB;IAE1C;;;;;;;OAOG;gBAEU,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GAAG,EAC5B,OAAO,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC;IAKjC,GAAG,IAAI,OAAO,CAAC,mBAAmB,CAAC;IA4BzC;;;;;;OAMG;YACW,QAAQ;CAezB;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CACrB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GAAG,EACnB,OAAO,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,GACpC,OAAO,CAAC,mBAAmB,CAAC,CAM9B"}

package/dist/browserTestUtil/types/current/benchmark/Benchmark.js

@@ -0,0 +1,247 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+//-------------------------------------------------------------------------
+// A Benchmarking utility for testing and comparing performance.
+//-------------------------------------------------------------------------
+/**
+ * Gets the current high resolution timestamp, platform dependent.
+ */
+let now;
+if (typeof window !== 'undefined' &&
+    typeof window.performance !== 'undefined' &&
+    typeof window.performance.now !== 'undefined') {
+    now = () => window.performance.now();
+}
+else if (typeof self !== 'undefined' &&
+    typeof self.performance !== 'undefined' &&
+    typeof self.performance.now !== 'undefined') {
+    now = () => self.performance.now();
+}
+else {
+    now = () => Date.now();
+}
+export class BenchmarkRunResults {
+    name;
+    cycleResults = [];
+    _totalSamples = 0;
+    get totalSamples() {
+        return this._totalSamples;
+    }
+    get cycleResultsNoOutliers() {
+        const sD = this.standardDeviation;
+        const avg = average(this.cycleResults);
+        return this.cycleResults.filter((e) => {
+            const zScore = (avg - e) / sD;
+            return Math.abs(zScore) < 3;
+        });
+    }
+    /**
+     * Returns the mean ops per second minus outliers of greater than 3 standard deviations.
+     */
+    get meanOpsPerSec() {
+        return average(this.cycleResultsNoOutliers);
+    }
+    get standardDeviation() {
+        return standardDeviation(this.cycleResults);
+    }
+    get variance() {
+        return this.standardDeviation / this.meanOpsPerSec;
+    }
+    /**
+     * Returns the mean ops / s ± variance % as a string.
+     */
+    get meanOpsStr() {
+        const mean = this.meanOpsPerSec.toLocaleString(undefined, {
+            maximumSignificantDigits: 4,
+        });
+        const variance = this.variance.toLocaleString(undefined, {
+            style: 'percent',
+        });
+        return `${mean} ±${variance}`;
+    }
+    constructor(name) {
+        this.name = name;
+    }
+    add(cycle) {
+        const opsPerSecond = cycle.ops / cycle.duration;
+        let index = this.cycleResults.findIndex((value) => opsPerSecond < value);
+        if (index < 0)
+            index = this.cycleResults.length;
+        this.cycleResults.splice(index, 0, opsPerSecond);
+        this._totalSamples += cycle.ops;
+    }
+    toString() {
+        if (!this.cycleResults.length)
+            return 'No results';
+        return `${this.name}: ${this.meanOpsStr} ops/sec`;
+    }
+}
+export class RunResultsComparison {
+    name;
+    /**
+     * Sorted by median ops/s from slowest to fastest.
+     */
+    results;
+    constructor(name, results) {
+        this.name = name;
+        this.results = results.sort((a, b) => {
+            return a.meanOpsPerSec - b.meanOpsPerSec;
+        });
+    }
+    logToTable() {
+        const r = this.results.map((run) => {
+            const variance = run.variance.toLocaleString(undefined, {
+                style: 'percent',
+            });
+            const mean = run.meanOpsPerSec.toLocaleString(undefined, {
+                maximumSignificantDigits: 4,
+            });
+            return {
+                Name: run.name,
+                Mean: `${mean} ±${variance}`,
+                Samples: run.totalSamples,
+                Compare: this.runComparisonToString(run),
+            };
+        });
+        // Use the names as the index.
+        const table = r.reduce((acc, { Name, ...x }) => {
+            acc[Name] = x;
+            return acc;
+        }, {});
+        console.log('\n' + this.name);
+        console.table(table);
+    }
+    runComparisonToString(run) {
+        const baseline = this.results[0]?.meanOpsPerSec ?? 0;
+        const fasterPercent = run.meanOpsPerSec / baseline - 1;
+        return fasterPercent < 0.01
+            ? '-'
+            : fasterPercent.toLocaleString(undefined, {
+                style: 'percent',
+            }) + ' faster';
+    }
+}
+export function compareResults(name, ...results) {
+    return new RunResultsComparison(name, results);
+}
+const defaultBenchmarkOptions = {
+    warmupTime: 0.5,
+    maxCycleDuration: 0.5,
+    cycles: 9,
+};
+export class Benchmark {
+    name;
+    executor;
+    static semaphore = nextFrame();
+    options;
+    /**
+     * Constructs a new Benchmark.
+     *
+     * @param name The name of the benchmark, to be used when logging.
+     * @param executor The method to execute and measure. If this method returns a promise, the
+     * promise will be awaited. The executor should either always return a promise, or never.
+     * @param options Optional configuration for the benchmark.
+     */
+    constructor(name, executor, options) {
+        this.name = name;
+        this.executor = executor;
+        this.options = { ...defaultBenchmarkOptions, ...options };
+    }
+    async run() {
+        const opts = this.options;
+        // Wait for any currently running work to complete.
+        await Benchmark.semaphore;
+        const warmupTimeMs = opts.warmupTime * 1000;
+        const cycleStart = now();
+        let isAsync = false;
+        do {
+            const result = this.executor();
+            // If the executor returns a promise, it is considered an async test and the benchmark
+            // should await its result.
+            isAsync = isAsync || (result && typeof result.then === 'function');
+            if (isAsync)
+                await result;
+        } while (now() - cycleStart < warmupTimeMs);
+        const resultsPromise = (async () => {
+            const results = new BenchmarkRunResults(this.name);
+            for (let i = 0; i < opts.cycles; i++) {
+                const cycleResults = await this.runCycle(isAsync);
+                results.add(cycleResults);
+                await nextFrame();
+            }
+            return results;
+        })();
+        Benchmark.semaphore = resultsPromise;
+        return await resultsPromise;
+    }
+    /**
+     * Runs one cycle. A cycle will repeat the executor approximately `options.maxCycleDuration`
+     * seconds.
+     *
+     * @param isAsync
+     * @return Returns the duration (in seconds) and number of operations the cycle repeated.
+     */
+    async runCycle(isAsync) {
+        const cycleMs = this.options.maxCycleDuration * 1000;
+        let ops = 0;
+        const cycleStart = now();
+        do {
+            const result = this.executor();
+            if (isAsync)
+                await result;
+            ops++;
+        } while (now() - cycleStart < cycleMs);
+        const duration = (now() - cycleStart) / 1000;
+        return {
+            duration,
+            ops,
+        };
+    }
+}
+/**
+ * Creates and runs a benchmark, logging the result.
+ *
+ * @param name
+ * @param executor
+ * @param options
+ */
+export function benchmark(name, executor, options) {
+    const benchmark = new Benchmark(name, executor, options);
+    return benchmark.run().then((results) => {
+        console.log(results.toString());
+        return results;
+    });
+}
+/**
+ * To avoid killing the browser's frame.
+ */
+function nextFrame() {
+    return new Promise((resolve) => {
+        setTimeout(resolve);
+    });
+}
+/**
+ * Returns the standard deviation of the given values.
+ *
+ * @param values
+ */
+function standardDeviation(values) {
+    const avg = average(values);
+    const squareDiffs = values.map((value) => {
+        const diff = value - avg;
+        return diff * diff;
+    });
+    const avgSquareDiff = average(squareDiffs);
+    return Math.sqrt(avgSquareDiff);
+}
+/**
+ * Returns the mean/average of the given values.
+ *
+ * @param values
+ */
+function average(values) {
+    const sum = values.reduce((acc, value) => acc + value, 0);
+    return sum / values.length;
+}

package/dist/browserTestUtil/types/current/env/jasmineEnv.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Sets the timeout for the current describe block.
+ *
+ * @param timeout The test timeout, in seconds.
+ */
+export declare function setTestTimeout(timeout: number): void;
+/**
+ * Sets the timeout for the next test and only the next test,
+ * overriding any value set subsequently to setTestTimeout.
+ *
+ * @param timeout The test timeout, in seconds.
+ */
+export declare function setNextTestTimeout(timeout: number): void;
+//# sourceMappingURL=jasmineEnv.d.ts.map

package/dist/browserTestUtil/types/current/env/jasmineEnv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jasmineEnv.d.ts","sourceRoot":"","sources":["../../../../../test/browserTestUtil/env/jasmineEnv.ts"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,QAY7C;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,QAGjD"}

package/dist/browserTestUtil/types/current/env/jasmineEnv.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+let nextTestTimeoutOverridden = false;
+/**
+ * Sets the timeout for the current describe block.
+ *
+ * @param timeout The test timeout, in seconds.
+ */
+export function setTestTimeout(timeout) {
+    let originalTimeout = null;
+    beforeEach(() => {
+        originalTimeout = jasmine.DEFAULT_TIMEOUT_INTERVAL;
+        if (!nextTestTimeoutOverridden)
+            jasmine.DEFAULT_TIMEOUT_INTERVAL = timeout * 1000;
+    });
+    afterEach(() => {
+        if (originalTimeout)
+            jasmine.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
+        if (nextTestTimeoutOverridden)
+            nextTestTimeoutOverridden = false;
+    });
+}
+/**
+ * Sets the timeout for the next test and only the next test,
+ * overriding any value set subsequently to setTestTimeout.
+ *
+ * @param timeout The test timeout, in seconds.
+ */
+export function setNextTestTimeout(timeout) {
+    nextTestTimeoutOverridden = true;
+    jasmine.DEFAULT_TIMEOUT_INTERVAL = timeout * 1000;
+}

package/dist/browserTestUtil/types/current/expect/expectIterableEquals.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Expects that two iterable objects have the same elements.
+ *
+ * @param arr1
+ * @param arr2
+ */
+export declare function expectIterableEquals<T>(arr1: Iterable<T> | ArrayLike<T>, arr2: Iterable<T> | ArrayLike<T>): void;
+//# sourceMappingURL=expectIterableEquals.d.ts.map

package/dist/browserTestUtil/types/current/expect/expectIterableEquals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expectIterableEquals.d.ts","sourceRoot":"","sources":["../../../../../test/browserTestUtil/expect/expectIterableEquals.ts"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAClC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,EAChC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,QAGnC"}

package/dist/browserTestUtil/types/current/expect/expectIterableEquals.js

@@ -0,0 +1,13 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Expects that two iterable objects have the same elements.
+ *
+ * @param arr1
+ * @param arr2
+ */
+export function expectIterableEquals(arr1, arr2) {
+    expect(Array.from(arr1)).toEqual(Array.from(arr2));
+}

package/dist/browserTestUtil/types/current/expect/expectNothing.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Some tests (such as benchmarks or type expectations) have no jasmine expectations.
+ */
+export declare function expectNothing(): void;
+//# sourceMappingURL=expectNothing.d.ts.map

package/dist/browserTestUtil/types/current/expect/expectNothing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expectNothing.d.ts","sourceRoot":"","sources":["../../../../../test/browserTestUtil/expect/expectNothing.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,wBAAgB,aAAa,SAE5B"}

package/dist/browserTestUtil/types/current/expect/expectNothing.js

@@ -0,0 +1,10 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Some tests (such as benchmarks or type expectations) have no jasmine expectations.
+ */
+export function expectNothing() {
+    expect(true).toBeTruthy();
+}

package/dist/browserTestUtil/types/current/expect/prototype.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Expect that the given factory produces an instance of `clazz` and `superClass`
+ * This is different from `expect(e).toBeInstanceOf` in that it accounts for TypeScript's branching
+ * if _super.call returns undefined.
+ *
+ * For example, IllegalArgumentError extends Error will produce the following constructor:
+ * ```
+ * var _this = _super.call(this, message) || this;
+ * Object.setPrototypeOf(_this, IllegalArgumentError.prototype);
+ * ```
+ * The branch of _super.call || this requires two tests for perfect coverage, one for the falsy
+ * case, and one for the truthy case.
+ *
+ * @param factory
+ * @param classes
+ */
+export declare function expectPrototype(factory: () => any, ...classes: any[]): void;
+//# sourceMappingURL=prototype.d.ts.map

package/dist/browserTestUtil/types/current/expect/prototype.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prototype.d.ts","sourceRoot":"","sources":["../../../../../test/browserTestUtil/expect/prototype.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,EAAE,GAAG,OAAO,EAAE,GAAG,EAAE,GAAG,IAAI,CAO3E"}

package/dist/browserTestUtil/types/current/expect/prototype.js

@@ -0,0 +1,28 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Expect that the given factory produces an instance of `clazz` and `superClass`
+ * This is different from `expect(e).toBeInstanceOf` in that it accounts for TypeScript's branching
+ * if _super.call returns undefined.
+ *
+ * For example, IllegalArgumentError extends Error will produce the following constructor:
+ * ```
+ * var _this = _super.call(this, message) || this;
+ * Object.setPrototypeOf(_this, IllegalArgumentError.prototype);
+ * ```
+ * The branch of _super.call || this requires two tests for perfect coverage, one for the falsy
+ * case, and one for the truthy case.
+ *
+ * @param factory
+ * @param classes
+ */
+export function expectPrototype(factory, ...classes) {
+    const e = factory();
+    classes.forEach((clazz) => expect(e).toBeInstanceOf(clazz));
+    const spy = spyOn(classes[classes.length - 1], 'call');
+    spy.and.returnValue(null);
+    const e2 = factory();
+    classes.forEach((clazz) => expect(e2).toBeInstanceOf(clazz));
+}

package/dist/browserTestUtil/types/current/expect/typesafety.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A type that equals true if Left and Right are strictly equal.
+ * Works with complex objects, readonly, and optional modifiers.
+ * Works with method input arguments.
+ * This will always equal true or false, and never the union `true | false`
+ */
+export type StrictEqual<Left, Right> = (<T>() => T extends Left ? 0 : 1) extends <T>() => T extends Right ? 0 : 1 ? Equal<Left, Right> : false;
+/**
+ * A type that equals true if Left and Right are loosely equal, that is, that Left extends Right
+ * and Right extends Left.
+ * This will always equal true or false, and never the union `true | false`
+ */
+export type Equal<Left, Right> = [Left] extends [Right] ? [Right] extends [Left] ? true : false : false;
+/**
+ * Adds a compile-time check that types Left and Right are identical.
+ */
+export declare function expectTypeStrictlyEquals<Left, Right>(_matches: StrictEqual<Left, Right>): void;
+/**
+ * Adds a compile-time check that type Left extends Right and Right extends Left.
+ * This is not as strict as `expectTypeStrictlyEquals`, it does not validate:
+ * - unknown types
+ * - any types
+ */
+export declare function expectTypeEquals<Left, Right>(_matches: Equal<Left, Right>): void;
+/**
+ * Adds a compile-time check that Sub extends Super.
+ * This is distributive, so `expectTypeExtends<1, 1 | 2>` will expect true.
+ */
+export declare function expectTypeExtends<Sub, Super>(_matches: [Sub] extends [Super] ? true : false): void;
+/**
+ * Adds a compile-time check that expects that the given type is exactly true.
+ */
+export declare function expectTypeTrue<T extends true>(): void;
+/**
+ * Adds a compile-time check that expects that the given type is exactly false.
+ */
+export declare function expectTypeFalse<T extends false>(): void;
+//# sourceMappingURL=typesafety.d.ts.map

package/dist/browserTestUtil/types/current/expect/typesafety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typesafety.d.ts","sourceRoot":"","sources":["../../../../../test/browserTestUtil/expect/typesafety.ts"],"names":[],"mappings":"AAaA;;;;;GAKG;AACH,MAAM,MAAM,WAAW,CAAC,IAAI,EAAE,KAAK,IAE/B,CAAC,CAAC,CAAC,OAAO,CAAC,SAAS,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,SAAS,KAAK,GAAG,CAAC,GAAG,CAAC,GACpE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,GAClB,KAAK,CAAA;AAEf;;;;GAIG;AACH,MAAM,MAAM,KAAK,CAAC,IAAI,EAAE,KAAK,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GACjD,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,GAClB,IAAI,GACJ,KAAK,GACT,KAAK,CAAA;AAEX;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,KAAK,EAChD,QAAQ,EAAE,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,GACnC,IAAI,CAEN;AAGD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,KAAK,EACxC,QAAQ,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,GAC7B,IAAI,CAEN;AAGD;;;GAGG;AAEH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,KAAK,EACxC,QAAQ,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,GAAG,KAAK,GAC/C,IAAI,CAEN;AAED;;GAEG;AAEH,wBAAgB,cAAc,CAAC,CAAC,SAAS,IAAI,KAAK,IAAI,CAErD;AAED;;GAEG;AAEH,wBAAgB,eAAe,CAAC,CAAC,SAAS,KAAK,KAAK,IAAI,CAEvD"}