@amazon/vinyl-util 3.0.1 → 3.2.0

package/dist/testUtil/types/current/patch/addPatchTests.js

@@ -1,54 +0,0 @@
-/*
- * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { expectNothing } from '@amazon/vinyl-util/browserTestUtil';
-/**
- * Adds tests to ensure that a patch flag is enabled when the issue can be reproduced for the UA,
- * and when the patch is applied the issue is no longer reproducible.
- *
- * @param flagName The flag name, used in test descriptions.
- * @param description The condition which requires the patch to be enabled.
- * @param optionsProvider
- */
-export function addPatchTests(flagName, description, optionsProvider) {
-    let options;
-    beforeEach(() => {
-        options = optionsProvider();
-    });
-    afterEach(() => {
-        // null safety check required, if test is skipped, beforeEach is not called but
-        // afterEach is.
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-        options?.patchedRef.dispose();
-    });
-    it('sets the default flag to true only if the issue can be reproduced', async () => {
-        const canReproduce = await options.canReproduce(options.target);
-        if (canReproduce) {
-            if (!options.actualFlag)
-                fail(`expected patch flag '${flagName}' to be true`);
-        }
-        else {
-            if (options.actualFlag) {
-                // The flag was true but the issue could not be reproduced.
-                // Most issues being patched cannot be reproduced with 100% reliability.
-                // Allow reproduction misses to be merely a warning instead of failing the test.
-                const message = `flag '${flagName}' was true but issue not reproduced`;
-                if (options.allowFalseNegative)
-                    console.warn(message);
-                else
-                    fail(message);
-            }
-        }
-        expectNothing();
-    });
-    describe(`when the ${flagName} is true`, () => {
-        it(description, async () => {
-            if (options.actualFlag) {
-                if (await options.canReproduce(options.patchedRef.patched))
-                    fail('patch did not resolve issue');
-            }
-            expectNothing();
-        });
-    });
-}

package/dist/testUtil/types/ts3.7/patch/addPatchTests.d.ts

@@ -1,35 +0,0 @@
-import { PatchedRef } from '@amazon/vinyl-util';
-export interface PatchTestOptions<T> {
-    /**
-     * True if the patch is enabled by default.
-     */
-    actualFlag: boolean | undefined;
-    /**
-     * The target, not patched.
-     */
-    target: T;
-    /**
-     * The patched target.
-     */
-    patchedRef: PatchedRef<T>;
-    /**
-     * Runs the scenario to reproduce the issue on the target.
-     * @param target
-     */
-    canReproduce: (target: T) => Promise<boolean>;
-    /**
-     * If true and the tested flag is true but the issue cannot be reproduced, then only a
-     * warning is logged, if false, then the test will be marked as a failure.
-     */
-    allowFalseNegative: boolean;
-}
-/**
- * Adds tests to ensure that a patch flag is enabled when the issue can be reproduced for the UA,
- * and when the patch is applied the issue is no longer reproducible.
- *
- * @param flagName The flag name, used in test descriptions.
- * @param description The condition which requires the patch to be enabled.
- * @param optionsProvider
- */
-export declare function addPatchTests<T>(flagName: string, description: string, optionsProvider: () => PatchTestOptions<T>): void;
-//# sourceMappingURL=addPatchTests.d.ts.map

package/dist/testUtil/types/ts4.1/patch/addPatchTests.d.ts

@@ -1,35 +0,0 @@
-import type { PatchedRef } from '@amazon/vinyl-util';
-export interface PatchTestOptions<T> {
-    /**
-     * True if the patch is enabled by default.
-     */
-    actualFlag: boolean | undefined;
-    /**
-     * The target, not patched.
-     */
-    target: T;
-    /**
-     * The patched target.
-     */
-    patchedRef: PatchedRef<T>;
-    /**
-     * Runs the scenario to reproduce the issue on the target.
-     * @param target
-     */
-    canReproduce: (target: T) => Promise<boolean>;
-    /**
-     * If true and the tested flag is true but the issue cannot be reproduced, then only a
-     * warning is logged, if false, then the test will be marked as a failure.
-     */
-    allowFalseNegative: boolean;
-}
-/**
- * Adds tests to ensure that a patch flag is enabled when the issue can be reproduced for the UA,
- * and when the patch is applied the issue is no longer reproducible.
- *
- * @param flagName The flag name, used in test descriptions.
- * @param description The condition which requires the patch to be enabled.
- * @param optionsProvider
- */
-export declare function addPatchTests<T>(flagName: string, description: string, optionsProvider: () => PatchTestOptions<T>): void;
-//# sourceMappingURL=addPatchTests.d.ts.map

package/dist/testUtil/types/ts4.7/patch/addPatchTests.d.ts

@@ -1,35 +0,0 @@
-import type { PatchedRef } from '@amazon/vinyl-util';
-export interface PatchTestOptions<T> {
-    /**
-     * True if the patch is enabled by default.
-     */
-    actualFlag: boolean | undefined;
-    /**
-     * The target, not patched.
-     */
-    target: T;
-    /**
-     * The patched target.
-     */
-    patchedRef: PatchedRef<T>;
-    /**
-     * Runs the scenario to reproduce the issue on the target.
-     * @param target
-     */
-    canReproduce: (target: T) => Promise<boolean>;
-    /**
-     * If true and the tested flag is true but the issue cannot be reproduced, then only a
-     * warning is logged, if false, then the test will be marked as a failure.
-     */
-    allowFalseNegative: boolean;
-}
-/**
- * Adds tests to ensure that a patch flag is enabled when the issue can be reproduced for the UA,
- * and when the patch is applied the issue is no longer reproducible.
- *
- * @param flagName The flag name, used in test descriptions.
- * @param description The condition which requires the patch to be enabled.
- * @param optionsProvider
- */
-export declare function addPatchTests<T>(flagName: string, description: string, optionsProvider: () => PatchTestOptions<T>): void;
-//# sourceMappingURL=addPatchTests.d.ts.map

package/dist/types/current/patch/patchTarget.d.ts

@@ -1,114 +0,0 @@
-import { type Disposable } from '../core/disposable';
-import type { Unsubscribe } from '../core/Unsubscribe';
-import { type Signal } from '../event/Signal';
-import type { AnyRecord } from '../util/type';
-import { type LogTarget } from '../logging/LogTarget';
-export interface Patch<in T, in EventMap = AnyRecord> extends Disposable {
-    /**
-     * A signal that emits synthetic events.
-     * These events will be dispatched on the proxy, not on the original event target.
-     * If undefined, no events are fabricated.
-     */
-    readonly eventFabricated?: Signal<Event>;
-    /**
-     * Overridden properties.
-     */
-    readonly properties?: PropertyPatches<T>;
-    /**
-     * Overridden events.
-     * Event patches may provide an alternate event to emit, or null to prevent an event from
-     * dispatching on the proxy.
-     *
-     * Note:
-     * Patched events have divergent behavior when using Event.stopImmediatePropagation.
-     * All handlers added to the patched Proxy will still be called after stopImmediatePropagation.
-     * It is the author's opinion that using stopImmediatePropagation is an anti-pattern, and one
-     * handler should not be allowed to influence the behavior of neighboring handlers.
-     */
-    readonly events?: EventPatches<EventMap>;
-}
-/**
- * A record of property key to property patch.
- */
-export type PropertyPatches<in T> = {
-    readonly [P in keyof T]?: PropertyPatch<T, P>;
-};
-/**
- * An override to a patched property.
- */
-export interface PropertyPatch<T, K extends keyof T> {
-    /**
-     * @return Returns the value to return on the proxy.
-     */
-    get?(): T[K];
-    /**
-     * @param newValue The property value attempting to be set.
-     */
-    set?(newValue: T[K]): void;
-}
-/**
- * Handles an event emitted from the event target. The returned event will be emitted in its
- * place on the proxy.
- *
- * Fabricated events from `eventFabricated` will not be passed to this handler and cannot be
- * squelched.
- *
- * @param event The original event from the event target. This should not be modified
- * directly, but may be cloned and a modified clone may be returned.
- *
- * @return Returns the event to emit on the proxy or null to squelch the event.
- */
-export type EventPatch<T> = (event: T) => T | null;
-/**
- * A record of event type to an event patch.
- */
-export type EventPatches<in EventMap> = {
-    readonly [P in keyof EventMap]?: EventPatch<EventMap[P]>;
-};
-export type PatchFactory<T, EventMap> = (target: T) => Patch<T, EventMap>;
-export interface PatchedRef<T> extends Disposable {
-    /**
-     * The patched target.
-     */
-    readonly patched: T;
-    /**
-     * A signal for when a synthetic event was fabricated.
-     */
-    eventFabricated: Signal<Event>;
-    /**
-     * A signal for when an event was squelched.
-     */
-    eventSquelched: Signal<Event>;
-}
-/**
- * Creates a Proxy for patched event and properties on the target. All patches from the provided
- * factory list will be used in creating a proxy chain. Each patch is applied in order, and
- * patches can rely on their target having been patched with all previous patches.
- *
- * @param target
- * @param patchFactories A list of factories that each produce a new patch for the target.
- * @return Returns a disposable object with a Proxy reference with overridden event and property
- * behavior. When disposed, the event listeners are removed.
- */
-export declare function patchTarget<T extends object, EventMap = AnyRecord>(target: T, ...patchFactories: PatchFactory<T, EventMap>[]): PatchedRef<T>;
-/**
- * Logs debug messages when an event was squelched or fabricated.
- *
- * @param pathTarget
- * @param patched
- * @return Returns a function that when invoked, removes the logging.
- */
-export declare function logPatchedEvents(pathTarget: LogTarget, patched: PatchedRef<any>): Unsubscribe;
-/**
- * A tuple of `[flag, factory]`.
- * Patches will be applied when flag is true.
- */
-export type FlagAndPatchEntry<T extends object, EventMap, Key> = readonly [
-    flagKey: Key,
-    factory: PatchFactory<T, EventMap>
-];
-/**
- * Given a list of [flagKey, patchFactory] tuples, patches the target with patches where flag is true.
- */
-export declare function patchTargetFromFlags<T extends object, EventMap, Flags>(target: T, flags: Flags, ...patchEntries: readonly FlagAndPatchEntry<T, EventMap, keyof Flags>[]): PatchedRef<T>;
-//# sourceMappingURL=patchTarget.d.ts.map

package/dist/types/current/patch/patchTarget.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"patchTarget.d.ts","sourceRoot":"","sources":["../../../../src/patch/patchTarget.ts"],"names":[],"mappings":"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"}

package/dist/types/current/patch/patchTarget.js

@@ -1,219 +0,0 @@
-/*
- * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
- * SPDX-License-Identifier: Apache-2.0
- */
-import { createDisposer, DisposedError, } from '../core/disposable';
-import { IllegalArgumentError } from '../error/IllegalArgumentError';
-import { EventHostImpl } from '../event/EventHost';
-import { emptySignal, SignalImpl } from '../event/Signal';
-import { logDebug } from '../logging/Logger';
-import { createLogPrefix } from '../logging/LogTarget';
-/**
- * Creates a Proxy for patched event and properties on the target. All patches from the provided
- * factory list will be used in creating a proxy chain. Each patch is applied in order, and
- * patches can rely on their target having been patched with all previous patches.
- *
- * @param target
- * @param patchFactories A list of factories that each produce a new patch for the target.
- * @return Returns a disposable object with a Proxy reference with overridden event and property
- * behavior. When disposed, the event listeners are removed.
- */
-export function patchTarget(target, ...patchFactories) {
-    const n = patchFactories.length;
-    if (n === 0) {
-        // Not patched
-        let disposed = false;
-        return {
-            patched: target,
-            eventFabricated: emptySignal,
-            eventSquelched: emptySignal,
-            dispose: () => {
-                // For consistency:
-                if (disposed)
-                    throw new DisposedError();
-                disposed = true;
-            },
-        };
-    }
-    else if (n === 1) {
-        return _patchTarget(target, patchFactories[0]);
-    }
-    else {
-        const { add, dispose } = createDisposer();
-        let patched = target;
-        const eventFabricated = add(new SignalImpl());
-        const eventSquelched = add(new SignalImpl());
-        const patchedChain = [];
-        patchFactories.forEach((factory) => {
-            const next = patchTarget(patched, factory);
-            patched = next.patched;
-            patchedChain.push(next);
-            next.eventFabricated.listen((event) => eventFabricated.dispatch(event));
-            next.eventSquelched.listen((event) => eventSquelched.dispatch(event));
-        });
-        // Patches must be disposed in reverse order
-        for (let i = patchedChain.length - 1; i >= 0; i--) {
-            add(patchedChain[i]);
-        }
-        return {
-            patched,
-            eventFabricated,
-            eventSquelched,
-            dispose,
-        };
-    }
-}
-/**
- * Creates a proxy to an event target that can patch properties and events.
- *
- * There are no modifications to the target, the returned proxy should be used in place of the
- * target.
- *
- * @param target
- * @param patchFactory Produces a new patch for the target.
- * @return Returns a disposable object with a Proxy reference with overridden event and property
- * behavior. When disposed, event listeners will be removed and the created patch and proxy will
- * be disposed.
- */
-function _patchTarget(target, patchFactory) {
-    const { add, dispose } = createDisposer();
-    const eventFabricated = add(new SignalImpl());
-    const eventSquelched = add(new SignalImpl());
-    // This method takes a factory instead of the EventTargetPatch directly to ensure that the
-    // patch disposal is handled with the proxy disposal.
-    const patch = add(patchFactory(target));
-    // An event target used in place of the original target for patched events.
-    const proxyEventHost = add(new EventHostImpl());
-    patch.eventFabricated?.listen((event) => {
-        eventFabricated.dispatch(event);
-        proxyEventHost.dispatch(event.type, event);
-    });
-    const delegatedEvents = new Set();
-    const subs = new Map();
-    let addEventListener = undefined;
-    let removeEventListener = undefined;
-    if (isEventTarget(target)) {
-        if (patch.events || patch.eventFabricated) {
-            const eventPatches = patch.events ?? {};
-            const observeTargetEvent = (type) => {
-                if (!delegatedEvents.has(type)) {
-                    delegatedEvents.add(type);
-                    const targetHandler = (event) => {
-                        const patchedEvent = event.type in eventPatches
-                            ? eventPatches[event.type](event)
-                            : event;
-                        if (patchedEvent)
-                            proxyEventHost.dispatch(patchedEvent.type, patchedEvent);
-                        else
-                            eventSquelched.dispatch(event);
-                    };
-                    target.addEventListener(type, targetHandler);
-                }
-            };
-            addEventListener = (type, callback, options) => {
-                if (typeof callback !== 'function')
-                    throw new IllegalArgumentError('only function callbacks are supported');
-                observeTargetEvent(type);
-                subs.set(callback, proxyEventHost.on(type, callback, {
-                    once: typeof options === 'object'
-                        ? (options.once ?? false)
-                        : false,
-                }));
-            };
-            removeEventListener = (_, callback) => {
-                if (typeof callback !== 'function')
-                    throw new IllegalArgumentError('only function callbacks are supported');
-                const sub = subs.get(callback);
-                if (sub) {
-                    subs.delete(callback);
-                    sub();
-                }
-            };
-            for (const eventPatchesKey in eventPatches) {
-                observeTargetEvent(eventPatchesKey);
-            }
-        }
-        else {
-            addEventListener = target.addEventListener.bind(target);
-            removeEventListener = target.removeEventListener.bind(target);
-        }
-    }
-    const propertyPatches = patch.properties ?? {};
-    const patched = new Proxy(target, {
-        get(target, p, receiver) {
-            const key = p;
-            if (key === 'addEventListener') {
-                return addEventListener;
-            }
-            else if (key === 'removeEventListener') {
-                return removeEventListener;
-            }
-            const patch = propertyPatches[key];
-            const value = patch && patch.get ? patch.get() : target[key];
-            if (typeof value === 'function') {
-                // Redirect the receiver from the Proxy to the target.
-                // While it may make more sense to just use the Proxy as the receiver (Liskov
-                // substitution principle), HTML DOM methods oddly have checks that enforce that the
-                // receiver is strictly the Element.
-                return function (...args) {
-                    return value.apply(this === receiver ? target : this, args);
-                };
-            }
-            return value;
-        },
-        set(target, p, newValue) {
-            const key = p;
-            const patch = propertyPatches[key];
-            if (patch && patch.set)
-                patch.set(newValue);
-            else
-                target[key] = newValue;
-            return true;
-        },
-    });
-    return {
-        patched,
-        eventFabricated,
-        eventSquelched,
-        // Certain supported platforms do not support Proxy.revocable, but this is not a
-        // requirement; we do not need to provide a Proxy to a consumer that needs its
-        // lifespan controlled.
-        dispose,
-    };
-}
-/**
- * Logs debug messages when an event was squelched or fabricated.
- *
- * @param pathTarget
- * @param patched
- * @return Returns a function that when invoked, removes the logging.
- */
-export function logPatchedEvents(pathTarget, patched) {
-    const eventSquelchedSub = patched.eventSquelched.listen((event) => logDebug(pathTarget, `'${event.type}' event squelched`));
-    const eventFabricatedSub = patched.eventFabricated.listen((event) => logDebug(pathTarget, `'${event.type}' event fabricated`));
-    return () => {
-        eventSquelchedSub();
-        eventFabricatedSub();
-    };
-}
-function isEventTarget(target) {
-    return 'addEventListener' in target;
-}
-/**
- * Given a list of [flagKey, patchFactory] tuples, patches the target with patches where flag is true.
- */
-export function patchTargetFromFlags(target, flags, ...patchEntries) {
-    const pathTarget = {
-        logPrefix: createLogPrefix('Patch'),
-    };
-    const filtered = patchEntries.filter(([key]) => {
-        const enabled = flags[key] === true;
-        if (enabled)
-            logDebug(pathTarget, `Applying '${String(key)}' patch`);
-        return enabled;
-    });
-    const patchedRef = patchTarget(target, ...filtered.map(([_, factory]) => factory));
-    // Logs fabricated and squelched events.
-    logPatchedEvents(pathTarget, patchedRef);
-    return patchedRef;
-}

package/dist/types/ts3.7/patch/patchTarget.d.ts

@@ -1,114 +0,0 @@
-import { Disposable } from '../core/disposable';
-import { Unsubscribe } from '../core/Unsubscribe';
-import { Signal } from '../event/Signal';
-import { AnyRecord } from '../util/type';
-import { LogTarget } from '../logging/LogTarget';
-export interface Patch<T, EventMap = AnyRecord> extends Disposable {
-    /**
-     * A signal that emits synthetic events.
-     * These events will be dispatched on the proxy, not on the original event target.
-     * If undefined, no events are fabricated.
-     */
-    readonly eventFabricated?: Signal<Event>;
-    /**
-     * Overridden properties.
-     */
-    readonly properties?: PropertyPatches<T>;
-    /**
-     * Overridden events.
-     * Event patches may provide an alternate event to emit, or null to prevent an event from
-     * dispatching on the proxy.
-     *
-     * Note:
-     * Patched events have divergent behavior when using Event.stopImmediatePropagation.
-     * All handlers added to the patched Proxy will still be called after stopImmediatePropagation.
-     * It is the author's opinion that using stopImmediatePropagation is an anti-pattern, and one
-     * handler should not be allowed to influence the behavior of neighboring handlers.
-     */
-    readonly events?: EventPatches<EventMap>;
-}
-/**
- * A record of property key to property patch.
- */
-export type PropertyPatches<T> = {
-    readonly [P in keyof T]?: PropertyPatch<T, P>;
-};
-/**
- * An override to a patched property.
- */
-export interface PropertyPatch<T, K extends keyof T> {
-    /**
-     * @return Returns the value to return on the proxy.
-     */
-    get?(): T[K];
-    /**
-     * @param newValue The property value attempting to be set.
-     */
-    set?(newValue: T[K]): void;
-}
-/**
- * Handles an event emitted from the event target. The returned event will be emitted in its
- * place on the proxy.
- *
- * Fabricated events from `eventFabricated` will not be passed to this handler and cannot be
- * squelched.
- *
- * @param event The original event from the event target. This should not be modified
- * directly, but may be cloned and a modified clone may be returned.
- *
- * @return Returns the event to emit on the proxy or null to squelch the event.
- */
-export type EventPatch<T> = (event: T) => T | null;
-/**
- * A record of event type to an event patch.
- */
-export type EventPatches<EventMap> = {
-    readonly [P in keyof EventMap]?: EventPatch<EventMap[P]>;
-};
-export type PatchFactory<T, EventMap> = (target: T) => Patch<T, EventMap>;
-export interface PatchedRef<T> extends Disposable {
-    /**
-     * The patched target.
-     */
-    readonly patched: T;
-    /**
-     * A signal for when a synthetic event was fabricated.
-     */
-    eventFabricated: Signal<Event>;
-    /**
-     * A signal for when an event was squelched.
-     */
-    eventSquelched: Signal<Event>;
-}
-/**
- * Creates a Proxy for patched event and properties on the target. All patches from the provided
- * factory list will be used in creating a proxy chain. Each patch is applied in order, and
- * patches can rely on their target having been patched with all previous patches.
- *
- * @param target
- * @param patchFactories A list of factories that each produce a new patch for the target.
- * @return Returns a disposable object with a Proxy reference with overridden event and property
- * behavior. When disposed, the event listeners are removed.
- */
-export declare function patchTarget<T extends object, EventMap = AnyRecord>(target: T, ...patchFactories: PatchFactory<T, EventMap>[]): PatchedRef<T>;
-/**
- * Logs debug messages when an event was squelched or fabricated.
- *
- * @param pathTarget
- * @param patched
- * @return Returns a function that when invoked, removes the logging.
- */
-export declare function logPatchedEvents(pathTarget: LogTarget, patched: PatchedRef<any>): Unsubscribe;
-/**
- * A tuple of `[flag, factory]`.
- * Patches will be applied when flag is true.
- */
-export type FlagAndPatchEntry<T extends object, EventMap, Key> = readonly [
-    /*flagKey*/ Key,
-    /*factory*/ PatchFactory<T, EventMap>
-];
-/**
- * Given a list of [flagKey, patchFactory] tuples, patches the target with patches where flag is true.
- */
-export declare function patchTargetFromFlags<T extends object, EventMap, Flags>(target: T, flags: Flags, ...patchEntries: readonly FlagAndPatchEntry<T, EventMap, keyof Flags>[]): PatchedRef<T>;
-//# sourceMappingURL=patchTarget.d.ts.map