@amazon/vinyl-util 1.0.0

package/dist/browserTestUtil/types/ts4.1/mock/dom/mockEvent.d.ts

@@ -0,0 +1,7 @@
+import { MockEvent } from './lib.dom';
+/**
+ * A convenience function to create a MockEvent with a given type.
+ * @param type
+ */
+export declare function mockEvent(type: string): MockEvent;
+//# sourceMappingURL=mockEvent.d.ts.map

package/dist/browserTestUtil/types/ts4.1/mock/implementEventFakes.d.ts

@@ -0,0 +1,17 @@
+export interface EventFakesHandle {
+    /**
+     * Returns true if there are any remaining listeners on this event target.
+     */
+    hasAnyListeners(): boolean;
+}
+/**
+ * Implements addEventListener, dispatchEvent, and removeEventListener.
+ * Simulates browser behavior for dispatching events.
+ *
+ * Does not differentiate between passive and active listeners or work with a dom hierarchy
+ * for bubble/capture phases.
+ *
+ * `dispatchEvent` must use subtypes of MockEvent.
+ */
+export declare function implementEventFakes(target: EventTarget): EventFakesHandle;
+//# sourceMappingURL=implementEventFakes.d.ts.map

package/dist/browserTestUtil/types/ts4.1/mock/polyfillCustomEvent.d.ts

@@ -0,0 +1,2 @@
+export declare function polyfillCustomEvent(): void;
+//# sourceMappingURL=polyfillCustomEvent.d.ts.map

package/dist/browserTestUtil/types/ts4.1/reporters/ConsoleReporter.d.ts

@@ -0,0 +1,10 @@
+import CustomReporter = jasmine.CustomReporter;
+import JasmineStartedInfo = jasmine.JasmineStartedInfo;
+import SpecResult = jasmine.SpecResult;
+export declare class ConsoleReporter implements CustomReporter {
+    private errors;
+    jasmineStarted(suiteInfo: JasmineStartedInfo): void;
+    specDone(result: SpecResult): void;
+    jasmineDone(): void;
+}
+//# sourceMappingURL=ConsoleReporter.d.ts.map

package/dist/browserTestUtil/types/ts4.7/async/async.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Returns a promise, when awaited, will ensure that all promise handlers are invoked.
+ */
+export declare function flushPromises(): Promise<void>;
+export interface MockTime {
+    /**
+     * Ticks forward `time` seconds, incrementally for each time argument.
+     * After each time increment, promises will be flushed.
+     * If no time values are provided, {@link flushPromises}, time will not be incremented, but
+     * will still be called.
+     *
+     * @param time (in seconds)
+     * @return Returns a promise which resolves after the last time increment and promise flush.
+     */
+    tick(...time: number[]): Promise<void>;
+    /**
+     * Sets the current date to the given date.
+     *
+     * @param date
+     */
+    mockDate(date?: Date): void;
+}
+/**
+ * Call within a `describe` block to install jasmine's mock clock between tests.
+ * The returned object has one difference from jasmine's Clock tick and setTime; a promise is
+ * returned, which when awaited, will ensure that promise handlers based on timed events will be
+ * called in the order in which they were intended.
+ */
+export declare function useMockTime(): MockTime;
+//# sourceMappingURL=async.d.ts.map

package/dist/browserTestUtil/types/ts4.7/async/createCallbackTimingTest.d.ts

@@ -0,0 +1,16 @@
+import type { MockTime } from '../async/async';
+/**
+ * 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 declare function createCallbackTimingTest(clock: MockTime, wrapCallback: (inner: () => void) => () => void): (input: string) => Promise<string>;
+//# sourceMappingURL=createCallbackTimingTest.d.ts.map

package/dist/browserTestUtil/types/ts4.7/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/ts4.7/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/ts4.7/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/ts4.7/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/ts4.7/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/ts4.7/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/ts4.7/expect/typesafety.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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/ts4.7/index.d.ts

@@ -0,0 +1,22 @@
+/** Auto-generated from build scripts */
+export * from './reporters/ConsoleReporter';
+export * from './mock/polyfillCustomEvent';
+export * from './mock/implementEventFakes';
+export * from './mock/createSpyFactory';
+export * from './mock/asSpy';
+export * from './mock/dom/mockEvent';
+export * from './mock/dom/lib.dom';
+export * from './mock/dom/globals';
+export * from './mock/dom/MockTimeRanges';
+export * from './matchers/toBeCloseToWithin';
+export * from './matchers/customMatchers';
+export * from './expect/typesafety';
+export * from './expect/prototype';
+export * from './expect/expectNothing';
+export * from './expect/expectIterableEquals';
+export * from './env/jasmineEnv';
+export * from './benchmark/Benchmark';
+export * from './async/marble';
+export * from './async/createCallbackTimingTest';
+export * from './async/async';
+//# sourceMappingURL=index.d.ts.map

package/dist/browserTestUtil/types/ts4.7/matchers/customMatchers.d.ts

@@ -0,0 +1,9 @@
+import type { WithToBeCloseToWithinMatcher } from './toBeCloseToWithin';
+declare global {
+    namespace jasmine {
+        interface Matchers<T> extends WithToBeCloseToWithinMatcher {
+        }
+    }
+}
+export declare function addCustomMatchers(): void;
+//# sourceMappingURL=customMatchers.d.ts.map

package/dist/browserTestUtil/types/ts4.7/matchers/toBeCloseToWithin.d.ts

@@ -0,0 +1,5 @@
+export interface WithToBeCloseToWithinMatcher {
+    toBeCloseToWithin(expected: number, tolerance?: number): boolean;
+}
+export declare function addToBeCloseToWithin(): void;
+//# sourceMappingURL=toBeCloseToWithin.d.ts.map

package/dist/browserTestUtil/types/ts4.7/mock/asSpy.d.ts

@@ -0,0 +1,18 @@
+import Spy = jasmine.Spy;
+/**
+ * A type representing any type of function.
+ */
+type Fun = (...args: any[]) => any;
+/**
+ * Creates or returns a Spy for a function on an object.
+ * If the method is already a spy, it will be returned.
+ * If not, a spy will be created.
+ *
+ * @param object
+ * @param method
+ */
+export declare function asSpy<T, K extends keyof T = keyof T>(object: T, method: T[K] extends Fun ? K : never): Spy<T[K] extends jasmine.Func ? T[K] : T[K] extends {
+    new (...args: infer A): infer V;
+} ? (...args: A) => V : never>;
+export {};
+//# sourceMappingURL=asSpy.d.ts.map

package/dist/browserTestUtil/types/ts4.7/mock/createSpyFactory.d.ts

@@ -0,0 +1,44 @@
+import Spy = jasmine.Spy;
+import SpyAnd = jasmine.SpyAnd;
+import Calls = jasmine.Calls;
+import MatchableArgs = jasmine.MatchableArgs;
+type Fun = (...args: any[]) => any;
+/**
+ * A SpyFactory creates spies by member access. The spies will be named based on the key,
+ * and the type interface of the Spy will match the corresponding interface function.
+ */
+export interface SpyFactory<T> {
+    <K extends FunctionKeys<T>>(key: K): T[K] extends Fun ? Spy2<NoThisType<NonNullable<T[K]>>> : never;
+}
+/**
+ *  Fixes Jasmine's Spy type.
+ *  Jasmine's Spy interface has a call signature instead of intersecting the original function type.
+ *  This causes parameterized types of the call signature to be dropped.
+ */
+export type Spy2<Fn extends Fun> = Fn & {
+    and: SpyAnd<Fn>;
+    calls: Calls<Fn>;
+    withArgs(...args: MatchableArgs<Fn>): Spy<Fn>;
+};
+export type FunctionKeys<T> = {
+    [P in keyof T]: T[P] extends Fun ? P : never;
+}[keyof T];
+/**
+ * Creates a new spy factory.
+ *
+ * @param createFake If provided, all spies will be created with the fake implementation createFake
+ * returns for the given key.
+ */
+export declare function createSpyFactory<T>(createFake?: (key: FunctionKeys<T>) => Fun): SpyFactory<T>;
+/**
+ * Creates a Spy.
+ * This is an alias to jasmine.createSpy with fixed type parameters.
+ * @param key
+ */
+export declare function createSpy2<Fn extends Fun | undefined>(key: keyof any): Spy2<NoThisType<NonNullable<Fn>>>;
+/**
+ * Replaces `this` type with `any` in a method signature.
+ */
+export type NoThisType<Fn extends Fun> = ReturnType<Fn> extends ThisType<any> ? Fn & ((...args: Parameters<Fn>) => any) : Fn;
+export {};
+//# sourceMappingURL=createSpyFactory.d.ts.map

package/dist/browserTestUtil/types/ts4.7/mock/dom/MockTimeRanges.d.ts

@@ -0,0 +1,15 @@
+/**
+ * An implementation of DOM TimeRanges that uses a source array of start/end tuples.
+ * For testing purposes only.
+ */
+export declare class MockTimeRanges implements TimeRanges {
+    private ranges;
+    constructor(ranges?: ReadonlyArray<readonly [
+        start: number,
+        end: number
+    ]>);
+    get length(): number;
+    start(index: number): number;
+    end(index: number): number;
+}
+//# sourceMappingURL=MockTimeRanges.d.ts.map

package/dist/browserTestUtil/types/ts4.7/mock/dom/globals.d.ts

@@ -0,0 +1,11 @@
+import { MockAbortSignal, MockMediaSource } from './lib.dom';
+export declare class MockMediaSourceGlobal extends MockMediaSource {
+    static canConstructInDedicatedWorker: boolean;
+    static isTypeSupported: import("../../mock/createSpyFactory").Spy2<((type: string) => boolean) & ((type: string) => any)>;
+}
+export declare class MockAbortSignalGlobal extends MockAbortSignal {
+    static abort: import("../../mock/createSpyFactory").Spy2<((reason?: any) => AbortSignal) & ((reason?: any) => any)>;
+    static any: import("../../mock/createSpyFactory").Spy2<((signals: AbortSignal[]) => AbortSignal) & ((signals: AbortSignal[]) => any)>;
+    static timeout: import("../../mock/createSpyFactory").Spy2<((milliseconds: number) => AbortSignal) & ((milliseconds: number) => any)>;
+}
+//# sourceMappingURL=globals.d.ts.map