@amazon/vinyl-util 1.0.0

package/dist/types/ts4.7/client/userAgent/userAgentRuleHelpers.d.ts

@@ -0,0 +1,52 @@
+import type { Maybe } from '../../util/type';
+import type { DeviceInfoRule, SystemInfoLikeRule, SystemInfoRule, TokenizedUserAgent } from './tokenizeUserAgent';
+/**
+ * A rule to match platform information (parts outside parentheticals).
+ *
+ * @param name The exact name to use if there's a match.
+ * @param expr
+ */
+export declare function uaPlatformRule(name: string, expr: string): SystemInfoRule;
+/**
+ * A rule to match system information. (Matches parts within parentheticals.)
+ *
+ * @param name The exact name to use if there's a match.
+ * @param expr
+ * @param hasVersion If true, the version will be inferred from the matched part.
+ */
+export declare function uaSystemRule(name: string, expr: string, hasVersion: boolean): SystemInfoRule;
+/**
+ * A rule to match platform or system information.
+ *
+ * @param name The exact name to use if there's a match.
+ * @param expr A token expression.
+ */
+export declare function uaPlatformOrSystemRule(name: string, expr: string): SystemInfoRule;
+/**
+ * Changes the name of the Name/Version part returned from the given rule.
+ *
+ * @param name
+ * @param rule
+ */
+export declare function uaName(name: string, rule: SystemInfoRule): SystemInfoRule;
+export declare function uaSystemLike(name: string, derived: readonly string[]): SystemInfoLikeRule;
+/**
+ * A rule to match system or platform information, providing vendor and type information.
+ *
+ * @param vendor The device make/vendor to use when there's a match.
+ * @param type The type of device, e.g. 'mobile' or 'tablet'.
+ * @param expr The token expression to use to determine a match. If there is a match, the
+ * matched name will be used as the model unless model is explicit.
+ * @param model If defined, will be used as the model string instead of the matched expression
+ * name.
+ */
+export declare function uaDeviceRule(vendor: string | null, type: string | null, expr: string, model?: Maybe<string>): DeviceInfoRule;
+/**
+ * A rule that executes a regex, transforming the match result.
+ *
+ * @param expr
+ * @param onMatch When the expression matches, onMatch will be given the RegExpExecArray and return
+ * the final info object.
+ */
+export declare function regexRule<T>(expr: RegExp, onMatch: (match: RegExpMatchArray) => T): (t: TokenizedUserAgent) => T | null;
+//# sourceMappingURL=userAgentRuleHelpers.d.ts.map

package/dist/types/ts4.7/core/Unsubscribe.d.ts

@@ -0,0 +1,2 @@
+export type Unsubscribe = () => void;
+//# sourceMappingURL=Unsubscribe.d.ts.map

package/dist/types/ts4.7/core/clearable.d.ts

@@ -0,0 +1,19 @@
+export interface Clearable {
+    /**
+     * Clears this object.
+     */
+    clear(): void;
+}
+/**
+ * Returns true if the value implements Clearable.
+ *
+ * @param value
+ */
+export declare function isClearable(value: any): value is Clearable;
+/**
+ * If the given object implements Clearable, executes clear.
+ *
+ * @param value
+ */
+export declare function maybeClear(value: any): void;
+//# sourceMappingURL=clearable.d.ts.map

package/dist/types/ts4.7/core/cloneable.d.ts

@@ -0,0 +1,14 @@
+/**
+ * An interface that may be implemented to provide custom clone behavior.
+ */
+export interface Cloneable<T> {
+    /**
+     * Produces a copy of this object.
+     */
+    clone(): T;
+}
+/**
+ * Returns true if the given value implements Cloneable.
+ */
+export declare function isCloneable<T>(value: T): value is T & Cloneable<T>;
+//# sourceMappingURL=cloneable.d.ts.map

package/dist/types/ts4.7/core/disposable.d.ts

@@ -0,0 +1,66 @@
+import { IllegalStateError } from '../error/IllegalStateError';
+import type { Unsubscribe } from '../core/Unsubscribe';
+import type { Maybe } from '../util/type';
+/**
+ * Any object that may be disposed.
+ */
+export interface Disposable {
+    dispose(): void;
+}
+/**
+ * Returns true if the given value is disposable.
+ *
+ * @param value Any value. The value will be considered Disposable if it contains a method named
+ * 'dispose', and that function requires zero parameters. This value will be type guarded to
+ * Disposable if true is returned.
+ */
+export declare function isDisposable(value: any): value is Disposable;
+/**
+ * Disposes all the given {@link Disposable} objects.
+ *
+ * @param disposables
+ */
+export declare function disposeAll(disposables: Iterable<Disposable>): void;
+/**
+ * Returns a Disposable that invokes the given function on dispose.
+ *
+ * @param unsub
+ */
+export declare function toDisposable(unsub: () => void): Disposable;
+export type AddDisposable = <T extends Maybe<Disposable | Unsubscribe>>(disposable: T) => T;
+/**
+ * A Disposer disposes added disposables as a group.
+ * The method members may be called without a receiver.
+ */
+export interface Disposer extends Disposable {
+    readonly disposed: boolean;
+    readonly add: AddDisposable;
+    readonly dispose: () => void;
+}
+/**
+ * Creates a Disposer, an object on which {@link Disposable} instances may be added, and disposed
+ * as a group.
+ *
+ * The method members may be called without a receiver, thus allowing destructuring.
+ * Example:
+ * ```
+ * function create(): Disposable {
+ *   const { dispose, add } = disposer()
+ *   add(someDisposable)
+ *   add(anotherDisposable)
+ *   return {
+ *     dispose
+ *   }
+ * }
+ * ```
+ *
+ */
+export declare function createDisposer(): Disposer;
+/**
+ * An illegal state error indicating that an object has been disposed.
+ */
+export declare class DisposedError extends IllegalStateError {
+    get [Symbol.toStringTag](): string;
+    constructor(message?: string);
+}
+//# sourceMappingURL=disposable.d.ts.map

package/dist/types/ts4.7/error/AbortError.d.ts

@@ -0,0 +1,6 @@
+import { ErrorLevel, ReportableError } from './ReportableError';
+export declare class AbortError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message?: string, origin?: string, level?: ErrorLevel);
+}
+//# sourceMappingURL=AbortError.d.ts.map

package/dist/types/ts4.7/error/ErrorOrigin.d.ts

@@ -0,0 +1,45 @@
+export declare const ErrorOrigin: {
+    /**
+     * The error originated from Vinyl and was reported from the uncaught exception or promise
+     * rejection handlers.
+     */
+    UNCAUGHT: string;
+    /**
+     * The error originated from Vinyl and was caught.
+     */
+    INTERNAL: string;
+    /**
+     * A Vinyl interface was used incorrectly by a consumer.
+     */
+    API: string;
+    /**
+     * The error originated from a failed service call (500 errors).
+     */
+    SERVICE_EXTERNAL: string;
+    /**
+     * The error originated from a failed service call (400 errors).
+     */
+    SERVICE_INTERNAL: string;
+    /**
+     * The error originated from a problem playing provided media.
+     * The reporter is from a component such as the element, source buffer, media source, etc.
+     */
+    MEDIA: string;
+    /**
+     * The error originated from a problem parsing input data.
+     * Such as a malformed Dash or HLS manifest.
+     */
+    PARSING: string;
+    /**
+     * The error originated from an incompatibility with browser APIs,
+     * such as EME.
+     */
+    COMPATIBILITY: string;
+    /**
+     * The error originated from DRM.
+     * This does not include internal or service errors, only errors from the creation of media keys or media key
+     * sessions.
+     */
+    DRM: string;
+};
+//# sourceMappingURL=ErrorOrigin.d.ts.map

package/dist/types/ts4.7/error/IllegalArgumentError.d.ts

@@ -0,0 +1,10 @@
+import { ReportableError } from './ReportableError';
+/**
+ * An error indicating that a method was called with illegal arguments.
+ */
+export declare class IllegalArgumentError extends ReportableError {
+    readonly isInternal: boolean;
+    get [Symbol.toStringTag](): string;
+    constructor(message: string, isInternal?: boolean);
+}
+//# sourceMappingURL=IllegalArgumentError.d.ts.map

package/dist/types/ts4.7/error/IllegalStateError.d.ts

@@ -0,0 +1,9 @@
+import { ReportableError } from './ReportableError';
+/**
+ * An error indicating an unexpected state.
+ */
+export declare class IllegalStateError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message: string);
+}
+//# sourceMappingURL=IllegalStateError.d.ts.map

package/dist/types/ts4.7/error/MediaUnsupportedError.d.ts

@@ -0,0 +1,9 @@
+import { ReportableError } from '../error/ReportableError';
+import type { Json } from '../util/serialization/json';
+export declare class MediaUnsupportedError extends ReportableError {
+    readonly code: string;
+    constructor(message: string, code: string);
+    toJSON(): Json;
+    get [Symbol.toStringTag](): string;
+}
+//# sourceMappingURL=MediaUnsupportedError.d.ts.map

package/dist/types/ts4.7/error/ReportableError.d.ts

@@ -0,0 +1,39 @@
+import type { Json } from '../util/serialization/json';
+export declare enum ErrorLevel {
+    /**
+     * Fatal errors are not recoverable.
+     */
+    FATAL = "fatal",
+    /**
+     * Warn level errors should be reported, but are recoverable.
+     */
+    WARN = "warn",
+    /**
+     * Silent errors should not be reported. For example aborting a play operation due to a new track loading.
+     */
+    SILENT = "silent"
+}
+/**
+ * A Serializable Error that contains an error origin.
+ */
+export declare class ReportableError extends Error {
+    readonly origin: string;
+    readonly level: ErrorLevel;
+    get [Symbol.toStringTag](): string;
+    constructor(message?: string, origin?: string, level?: ErrorLevel);
+    get name(): string;
+    /**
+     * All ReportableError instances must be serializable.
+     */
+    toJSON(): Json;
+}
+/**
+ * Returns true if the given object is a ReportableError.
+ */
+export declare function isReportableError(error: any): error is ReportableError;
+/**
+ * Returns true if the error is a ReportableError and is level SILENT.
+ * @param error
+ */
+export declare function isSilentError(error: any): boolean;
+//# sourceMappingURL=ReportableError.d.ts.map

package/dist/types/ts4.7/error/ServiceResponseError.d.ts

@@ -0,0 +1,14 @@
+import { ReportableError } from './ReportableError';
+import { type Json } from '../util/serialization/json';
+export declare const SERVICE_RESPONSE_ERROR_MESSAGE = "Unexpected service response";
+export declare class ServiceResponseError extends ReportableError {
+    readonly reason: any;
+    constructor(reason: any);
+    get [Symbol.toStringTag](): string;
+    toJSON(): Json;
+}
+/**
+ * When used in a catch clause of a promise, wraps the reason in a {@link ServiceResponseError}.
+ */
+export declare function throwServiceResponse(reason: any): never;
+//# sourceMappingURL=ServiceResponseError.d.ts.map

package/dist/types/ts4.7/error/StackOverflowError.d.ts

@@ -0,0 +1,9 @@
+import { ReportableError } from './ReportableError';
+/**
+ * An error indicating a stack overflow has occurred.
+ */
+export declare class StackOverflowError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message: string);
+}
+//# sourceMappingURL=StackOverflowError.d.ts.map

package/dist/types/ts4.7/error/TimeoutError.d.ts

@@ -0,0 +1,6 @@
+import { ErrorLevel, ReportableError } from './ReportableError';
+export declare class TimeoutError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message: string, origin?: string, level?: ErrorLevel);
+}
+//# sourceMappingURL=TimeoutError.d.ts.map

package/dist/types/ts4.7/error/UnreachableCodeError.d.ts

@@ -0,0 +1,9 @@
+import { ReportableError } from './ReportableError';
+/**
+ * An error indicating that a line of code was hit that should not be possible.
+ */
+export declare class UnreachableCodeError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor();
+}
+//# sourceMappingURL=UnreachableCodeError.d.ts.map

package/dist/types/ts4.7/error/ValidationError.d.ts

@@ -0,0 +1,17 @@
+import { ReportableError } from '../error/ReportableError';
+import type { Json } from '../util/serialization/json';
+/**
+ * An error indicating that input had an invalid shape.
+ */
+export declare class ValidationError extends ReportableError {
+    readonly path: readonly string[];
+    get [Symbol.toStringTag](): string;
+    /**
+     * @param message The validation error message.
+     * @param origin The error origin, typically API (default) or SERVICE_EXTERNAL
+     * @param path The property path to the invalid field.
+     */
+    constructor(message: string, origin?: string, path?: readonly string[]);
+    toJSON(): Json;
+}
+//# sourceMappingURL=ValidationError.d.ts.map

package/dist/types/ts4.7/event/DomEventHost.d.ts

@@ -0,0 +1,45 @@
+import type { Disposable } from '../core/disposable';
+import type { ReadonlyEventHost } from './EventHost';
+import type { EventHandler, SignalOptions } from './Signal';
+import type { Unsubscribe } from '../core/Unsubscribe';
+import type { ExtractValues } from '../util/type';
+/**
+ * Picks the keys from T that satisfy: `[keyof T extends string]: Event`
+ */
+export type DomEventMap<T> = ExtractValues<Pick<T, keyof T & string>, Event>;
+export interface DomReadonlyEventHost<EventMap> extends ReadonlyEventHost<DomEventMap<EventMap>> {
+    /**
+     * Adds an event handler for the given typed event.
+     *
+     * @param type A case-sensitive string representing the event type to listen for.
+     * @param handler A callback to invoke when the event with the given type is dispatched.
+     * @param options An options object specifies characteristics about the event listener.
+     * @return Returns a method, when invoked, removes the handler.
+     */
+    on<K extends keyof DomEventMap<EventMap>>(type: K, handler: EventHandler<DomEventMap<EventMap>[K]>, options?: DomEventListenerOptions): Unsubscribe;
+}
+/**
+ * Event listener options for DOM events.
+ *
+ * Note: signal not supported, use abort utilities.
+ */
+export interface DomEventListenerOptions extends SignalOptions, Omit<AddEventListenerOptions, 'signal'> {
+}
+/**
+ * Wraps a js `EventTarget` with a {@link ReadonlyEventHost} interface.
+ */
+export declare class DomEventHost<EventMap> implements DomReadonlyEventHost<EventMap>, Disposable {
+    protected readonly eventTarget: EventTarget;
+    private activeSubs;
+    private listenerCounts;
+    constructor(eventTarget: EventTarget);
+    hasAnyListeners(): boolean;
+    hasListeners(type: keyof DomEventMap<EventMap>): boolean;
+    on<K extends keyof DomEventMap<EventMap>>(type: K, handler: EventHandler<DomEventMap<EventMap>[K]>, options?: DomEventListenerOptions): Unsubscribe;
+    /**
+     * Disposal of a DomEventHost removes all listeners.
+     */
+    dispose(): void;
+    __eventMapType: import("../util/type").Covariant<EventMap>;
+}
+//# sourceMappingURL=DomEventHost.d.ts.map

package/dist/types/ts4.7/event/EventHost.d.ts

@@ -0,0 +1,69 @@
+import type { Disposable } from '../core/disposable';
+import type { EventHandler, SignalOptions } from './Signal';
+import type { Unsubscribe } from '../core/Unsubscribe';
+import type { Covariant } from '../util/type';
+import { type LogTarget } from '../logging/LogTarget';
+export interface EventDispatcher<in EventMap> extends LogTarget {
+    /**
+     * Dispatches an event.
+     *
+     * @param type The key of the event within `EventMap`
+     * @param event If the passed event is read-only, then it may be re-used/cached. Otherwise,
+     * it should be a new event object every dispatch. If no target property is set on the event,
+     * the target will be set to this host.
+     */
+    dispatch<K extends keyof EventMap>(type: K, event: EventMap[K]): void;
+}
+export interface ReadonlyEventHost<out EventMap> {
+    /**
+     * Adds an event handler for the given typed event.
+     *
+     * @param type The key representing the event type to listen for.
+     * @param handler A callback to invoke when the event with the given type is dispatched.
+     * @param options Options for changing listening behavior.
+     * @return Returns a method, when invoked, removes the handler.
+     */
+    on<K extends keyof EventMap>(type: K, handler: EventHandler<EventMap[K]>, options?: SignalOptions): Unsubscribe;
+    /**
+     * Returns true if the event host has any listeners.
+     */
+    hasAnyListeners(): boolean;
+    /**
+     * Returns true if the event host has any listeners for the given type.
+     */
+    hasListeners(type: keyof EventMap): boolean;
+    /**
+     * Exists for EventMap type inference.
+     *
+     * @private
+     */
+    __eventMapType: Covariant<EventMap>;
+}
+/**
+ * An object that may dispatch events and have handlers for those events.
+ * Similar to the DOM's `EventTarget`, this is a basic event system based on event naming.
+ *
+ * Some of the advantages of EventHost over EventTarget:
+ * - Not all supported platforms support EventTarget construction or extension.
+ * - EventTarget is designed for the DOM, with bubble and capture phases not necessary in Vinyl.
+ * - Event types are strict.
+ * - Events can be plain objects, no need to extend CustomEvent.
+ * - Easier unsubscription and disposal; reduces the risk of memory leaks.
+ *
+ * EventHost supports concurrent modification, that is, handlers may be added or removed during
+ * the execution of another handler.
+ */
+export interface EventHost<EventMap> extends ReadonlyEventHost<EventMap>, EventDispatcher<EventMap> {
+}
+export declare class EventHostImpl<EventMap> implements EventHost<EventMap>, Disposable {
+    get [Symbol.toStringTag](): string;
+    readonly logPrefix: string;
+    private readonly signals;
+    hasAnyListeners(): boolean;
+    hasListeners(type: keyof EventMap): boolean;
+    on<K extends keyof EventMap>(type: K, handler: EventHandler<EventMap[K]>, options?: SignalOptions): Unsubscribe;
+    dispatch<K extends keyof EventMap>(type: K, event: EventMap[K]): void;
+    dispose(): void;
+    __eventMapType: Covariant<EventMap>;
+}
+//# sourceMappingURL=EventHost.d.ts.map

package/dist/types/ts4.7/event/Signal.d.ts

@@ -0,0 +1,57 @@
+import type { Disposable } from '../core/disposable';
+import type { Unsubscribe } from '../core/Unsubscribe';
+export type EventHandler<in T> = (event: T) => void;
+export interface SignalOptions {
+    /**
+     * If true, removes the handler after the first invocation.
+     */
+    once?: boolean;
+}
+export interface Signal<T> {
+    /**
+     * Returns true if this signal has no handlers.
+     */
+    readonly empty: boolean;
+    /**
+     * Adds an event handler that will be invoked upon signal dispatch.
+     *
+     * @param handler The handler to invoke on signal dispatch.
+     * @param options Options for changing listening behavior.
+     * @return Unsubscribe - Returns a method where, when invoked, will remove the handler.
+     * If the handler has already been removed, Unsubscribe will do nothing.
+     */
+    listen(handler: EventHandler<T>, options?: SignalOptions): Unsubscribe;
+}
+/**
+ * An object that may dispatch one type of event and have handlers for that event.
+ */
+export declare class SignalImpl<T> implements Signal<T>, Disposable {
+    private handlers;
+    get empty(): boolean;
+    listen(handler: EventHandler<T>, options?: SignalOptions): Unsubscribe;
+    /**
+     * Invokes all handlers, providing the given event.
+     *
+     * Handlers may add/remove callbacks or do a nested dispatch.
+     *
+     * If a handler is added within a handler, the new handler will not be invoked until the
+     * next dispatch.
+     *
+     * @param event
+     */
+    dispatch(event: T): void;
+    /**
+     * Removes all handlers.
+     */
+    clear(): void;
+    /**
+     * Same as clear.
+     */
+    dispose(): void;
+}
+/**
+ * Constructs a new SignalImpl.
+ */
+export declare function signal<T>(): SignalImpl<T>;
+export declare const emptySignal: Signal<any>;
+//# sourceMappingURL=Signal.d.ts.map

package/dist/types/ts4.7/event/nextEventAsPromise.d.ts

@@ -0,0 +1,30 @@
+import type { ReadonlyEventHost } from './EventHost';
+import type { ReadonlyAbort } from '../util/async/Abort';
+import type { Maybe } from '../util/type';
+export interface NextEventAsPromiseOptions<EventMap, K extends keyof EventMap> {
+    /**
+     * (Optional) If provided, will only resolve if the event passes this predicate.
+     */
+    filter?: ((event: EventMap[K]) => boolean) | undefined | null;
+    /**
+     * (Optional) If provided, will reject the promise if the signal is aborted.
+     */
+    abort?: Maybe<ReadonlyAbort>;
+    /**
+     * If provided, the promise will reject after this duration, in seconds, if not resolved.
+     */
+    timeout?: number;
+    /**
+     * The timeout message. If not provided will use `DEFAULT_TIMEOUT_MESSAGE`.
+     */
+    timeoutMessage?: string;
+}
+/**
+ * Promisifies the next event.
+ *
+ * @param host The event host to observe.
+ * @param type The name of the event.
+ * @param options Optional configuration, to provide abort
+ */
+export declare function nextEventAsPromise<EventMap, K extends keyof EventMap>(host: ReadonlyEventHost<EventMap>, type: K, options?: Maybe<NextEventAsPromiseOptions<EventMap, K>>): Promise<EventMap[K]>;
+//# sourceMappingURL=nextEventAsPromise.d.ts.map

package/dist/types/ts4.7/event/onAny.d.ts

@@ -0,0 +1,13 @@
+import type { Unsubscribe } from '../core/Unsubscribe';
+import type { ReadonlyEventHost } from './EventHost';
+import type { SignalOptions } from './Signal';
+/**
+ * Adds a single handler to all given event types on an event host.
+ *
+ * @param host The event host.
+ * @param types An array of event types.
+ * @param handler A handler to be called if any of the given event types are dispatched.
+ * @param options If once is true, the first event called will remove the handler.
+ */
+export declare function onAny<EventMap, K extends keyof EventMap>(host: ReadonlyEventHost<EventMap>, types: readonly K[], handler: <U extends K>(event: EventMap[U], type: U) => void, options?: SignalOptions): Unsubscribe;
+//# sourceMappingURL=onAny.d.ts.map

package/dist/types/ts4.7/event/redispatchEvents.d.ts

@@ -0,0 +1,15 @@
+import type { EventDispatcher, ReadonlyEventHost } from './EventHost';
+import type { Unsubscribe } from '../core/Unsubscribe';
+/**
+ * Listens to an event host for a list of events, re-dispatching those events on this target
+ * dispatcher.
+ * Useful for event delegation.
+ *
+ * @param dispatcher The dispatcher on which to re-dispatch events.
+ * @param eventHost The readonly event host that emits the events to be re-dispatched.
+ * @param eventTypes The event types from eventHost to delegate to the dispatcher. These are the
+ * keys in the event map that should be delegated.
+ * @return Returns a method that when invoked, will unsubscribe from all delegated events.
+ */
+export declare function redispatchEvents<EventMap, K extends keyof EventMap>(dispatcher: EventDispatcher<Pick<EventMap, K>>, eventHost: ReadonlyEventHost<EventMap>, eventTypes: readonly K[]): Unsubscribe;
+//# sourceMappingURL=redispatchEvents.d.ts.map

package/dist/types/ts4.7/global/environment.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Returns true if this is a nodejs environment.
+ */
+export declare function isNode(): boolean;
+/**
+ * Node's global setTimeout differs slightly from the browser. Use this when storing timeout ids.
+ */
+export type TimeoutId = ReturnType<typeof setTimeout>;
+/**
+ * A subset of `Location` properties available in all environments.
+ */
+export interface PartialLocation {
+    readonly origin: string;
+    readonly search: string;
+    readonly href: string;
+}
+/**
+ * Returns the global `location` object, or a default with empty values
+ * when `location` is not defined (e.g. Node, Web Workers).
+ */
+export declare function getLocation(): PartialLocation;
+/**
+ * Node's global setInterval differs slightly from the browser. Use this when storing interval ids.
+ */
+export type IntervalId = ReturnType<typeof setInterval>;
+//# sourceMappingURL=environment.d.ts.map