@amazon/vinyl-util 1.0.0

package/dist/types/current/event/EventHost.js

@@ -0,0 +1,38 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { signal } from './Signal';
+import { getOrSet } from '../util/map/map';
+import { covariant } from '../util/type';
+import { createLogPrefix } from '../logging/LogTarget';
+export class EventHostImpl {
+    get [Symbol.toStringTag]() {
+        return 'EventHostImpl';
+    }
+    logPrefix = createLogPrefix(this);
+    signals = new Map();
+    hasAnyListeners() {
+        for (const value of this.signals.values()) {
+            if (!value.empty)
+                return true;
+        }
+        return false;
+    }
+    hasListeners(type) {
+        return this.signals.get(type)?.empty === false;
+    }
+    on(type, handler, options) {
+        const sig = getOrSet(this.signals, type, () => signal());
+        return sig.listen(handler, options);
+    }
+    dispatch(type, event) {
+        this.signals.get(type)?.dispatch(event);
+    }
+    dispose() {
+        for (const signal of this.signals.values())
+            signal.dispose();
+        this.signals.clear();
+    }
+    __eventMapType = covariant();
+}

package/dist/types/current/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/current/event/Signal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Signal.d.ts","sourceRoot":"","sources":["../../../../src/event/Signal.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAGrD,MAAM,MAAM,YAAY,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAA;AAEnD,MAAM,WAAW,aAAa;IAC1B;;OAEG;IACH,IAAI,CAAC,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,WAAW,MAAM,CAAC,CAAC;IACrB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IAEvB;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,WAAW,CAAA;CACzE;AAED;;GAEG;AACH,qBAAa,UAAU,CAAC,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC,EAAE,UAAU;IACvD,OAAO,CAAC,QAAQ,CAAsC;IAEtD,IAAI,KAAK,IAAI,OAAO,CAEnB;IAED,MAAM,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,WAAW;IAatE;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IASxB;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,OAAO,IAAI,IAAI;CAGlB;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,KAAK,UAAU,CAAC,CAAC,CAAC,CAEzC;AAED,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,GAAG,CAMnC,CAAA"}

package/dist/types/current/event/Signal.js

@@ -0,0 +1,66 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { LinkedList } from '../util/collection/LinkedList';
+/**
+ * An object that may dispatch one type of event and have handlers for that event.
+ */
+export class SignalImpl {
+    handlers = new LinkedList();
+    get empty() {
+        return this.handlers.empty;
+    }
+    listen(handler, options) {
+        const remove = () => this.handlers.remove(node);
+        const node = this.handlers.push(options?.once
+            ? (event) => {
+                remove();
+                handler(event);
+            }
+            : handler);
+        return remove;
+    }
+    /**
+     * 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) {
+        const handlers = this.handlers;
+        const tail = handlers.tail;
+        handlers.some((handler) => {
+            handler(event);
+            return handler === tail.value;
+        });
+    }
+    /**
+     * Removes all handlers.
+     */
+    clear() {
+        this.handlers.clear();
+    }
+    /**
+     * Same as clear.
+     */
+    dispose() {
+        this.clear();
+    }
+}
+/**
+ * Constructs a new SignalImpl.
+ */
+export function signal() {
+    return new SignalImpl();
+}
+export const emptySignal = {
+    empty: true,
+    listen() {
+        return () => { };
+    },
+};

package/dist/types/current/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/current/event/nextEventAsPromise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nextEventAsPromise.d.ts","sourceRoot":"","sources":["../../../../src/event/nextEventAsPromise.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAGvD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAExC,MAAM,WAAW,yBAAyB,CAAC,QAAQ,EAAE,CAAC,SAAS,MAAM,QAAQ;IACzE;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,GAAG,SAAS,GAAG,IAAI,CAAA;IAE7D;;OAEG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC,CAAA;IAE5B;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,CAAC,SAAS,MAAM,QAAQ,EACjE,IAAI,EAAE,iBAAiB,CAAC,QAAQ,CAAC,EACjC,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,KAAK,CAAC,yBAAyB,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,GACxD,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAatB"}

package/dist/types/current/event/nextEventAsPromise.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { promise } from '../util/async/promise';
+import { withTimeout } from '../util/async/timeout';
+/**
+ * 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 function nextEventAsPromise(host, type, options) {
+    return withTimeout(promise((resolve) => {
+        return host.on(type, (event) => {
+            if (!options?.filter || options.filter(event)) {
+                resolve(event);
+            }
+        });
+    }, options?.abort), options?.timeout, options?.timeoutMessage ??
+        `Event '${String(type)}' was not received within {time}s`);
+}

package/dist/types/current/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/current/event/onAny.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onAny.d.ts","sourceRoot":"","sources":["../../../../src/event/onAny.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7C;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,CAAC,SAAS,MAAM,QAAQ,EACpD,IAAI,EAAE,iBAAiB,CAAC,QAAQ,CAAC,EACjC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,OAAO,EAAE,CAAC,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,IAAI,EAC3D,OAAO,CAAC,EAAE,aAAa,GACxB,WAAW,CAWb"}

package/dist/types/current/event/onAny.js

@@ -0,0 +1,24 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createDisposer } from '../core/disposable';
+/**
+ * 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 function onAny(host, types, handler, options) {
+    const { dispose, add } = createDisposer();
+    for (const type of types) {
+        add(host.on(type, (e) => {
+            if (options?.once)
+                dispose();
+            handler(e, type);
+        }));
+    }
+    return dispose;
+}

package/dist/types/current/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/current/event/redispatchEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redispatchEvents.d.ts","sourceRoot":"","sources":["../../../../src/event/redispatchEvents.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAErD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,CAAC,SAAS,MAAM,QAAQ,EAC/D,UAAU,EAAE,eAAe,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,EAC9C,SAAS,EAAE,iBAAiB,CAAC,QAAQ,CAAC,EACtC,UAAU,EAAE,SAAS,CAAC,EAAE,GACzB,WAAW,CAMb"}

package/dist/types/current/event/redispatchEvents.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createDisposer } from '../core/disposable';
+/**
+ * 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 function redispatchEvents(dispatcher, eventHost, eventTypes) {
+    const { dispose, add } = createDisposer();
+    for (const type of eventTypes) {
+        add(eventHost.on(type, (e) => dispatcher.dispatch(type, e)));
+    }
+    return dispose;
+}

package/dist/types/current/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

package/dist/types/current/global/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../../../src/global/environment.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,wBAAgB,MAAM,IAAI,OAAO,CAQhC;AACD;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA;AAErD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACxB;AAED;;;GAGG;AACH,wBAAgB,WAAW,IAAI,eAAe,CAE7C;AAQD;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAA"}

package/dist/types/current/global/environment.js

@@ -0,0 +1,29 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+let _isNode = null;
+/**
+ * Returns true if this is a nodejs environment.
+ */
+export function isNode() {
+    if (_isNode === null) {
+        _isNode =
+            typeof process !== 'undefined' &&
+                'versions' in process &&
+                typeof process.versions.node === 'string';
+    }
+    return _isNode;
+}
+/**
+ * Returns the global `location` object, or a default with empty values
+ * when `location` is not defined (e.g. Node, Web Workers).
+ */
+export function getLocation() {
+    return typeof location === 'object' ? location : defaultLocation;
+}
+const defaultLocation = {
+    origin: '',
+    search: '',
+    href: '',
+};

package/dist/types/current/global/globalRegistry.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Manages global initializers.
+ */
+export declare class GlobalRegistry {
+    private registry;
+    /**
+     * Returns the number of references currently in the registry.
+     */
+    get size(): number;
+    /**
+     * Registers an initializer that will be invoked during global state initialization.
+     * @param initializer
+     */
+    register<T extends GlobalRef<any>>(initializer: T): T;
+    /**
+     * Removes a global ref from the registry.
+     * May be called at any time.
+     * @param ref
+     * @return Returns true if the global ref was removed.
+     */
+    unregister(ref: GlobalRef<any>): boolean;
+    /**
+     * Resets all registered initializers and sets this registry back to its pre-initialized state.
+     * This is typically only done within unit tests, but may be called if all players are
+     * disposed and the consumer intends to teardown global state.
+     */
+    reset(): void;
+}
+/**
+ * Gets or creates the global registry instance.
+ */
+export declare function getGlobalRegistry(): GlobalRegistry;
+export interface GlobalRef<T> {
+    /**
+     * True if this has been initialized.
+     */
+    readonly initialized: boolean;
+    /**
+     * Returns the factory-produced value.
+     * Throws an {@link IllegalStateError} if the global registry has not been initialized.
+     */
+    readonly value: T;
+    /**
+     * Overrides this initializer.
+     * The previous initializer will be provided as an argument for extension.
+     *
+     * Throws an {@link IllegalStateError} if the global registry has been initialized.
+     * @return Returns this
+     */
+    set(newInitializer: (previousInitializer: () => T) => T): GlobalRef<T>;
+    /**
+     * Resets this initializer back to its pre-initialized state.
+     * If the initializer produced a disposable value, it will be disposed.
+     */
+    reset(): void;
+    /**
+     * Initializes the global ref.
+     * This is done automatically on first use of `value`, but may be initialized eagerly.
+     */
+    initialize(): void;
+}
+export declare function setGlobalRefDebug(enabled: boolean): void;
+export declare class GlobalRefImpl<T> implements GlobalRef<T> {
+    private readonly defaultInitializer;
+    private _value;
+    private _initialized;
+    private constructing;
+    private initializer;
+    private lastInitStack;
+    constructor(defaultInitializer: () => T);
+    get initialized(): boolean;
+    get value(): T;
+    reset(): void;
+    initialize(): void;
+    set(newInitializer: (previousInitializer: () => T) => T): GlobalRef<T>;
+    private assertNotInitialized;
+    private assertNotConstructing;
+}
+/**
+ * Creates a global reference that can be lazily initialized.
+ * This function is tree-shakable as it doesn't perform any side effects on import.
+ *
+ * @param init Factory function that creates the value
+ */
+export declare function globalRef<T>(init: () => T): GlobalRef<T>;
+//# sourceMappingURL=globalRegistry.d.ts.map

package/dist/types/current/global/globalRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalRegistry.d.ts","sourceRoot":"","sources":["../../../../src/global/globalRegistry.ts"],"names":[],"mappings":"AAUA;;GAEG;AACH,qBAAa,cAAc;IACvB,OAAO,CAAC,QAAQ,CAAuB;IAEvC;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;OAGG;IACH,QAAQ,CAAC,CAAC,SAAS,SAAS,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,CAAC,GAAG,CAAC;IAKrD;;;;;OAKG;IACH,UAAU,CAAC,GAAG,EAAE,SAAS,CAAC,GAAG,CAAC,GAAG,OAAO;IAIxC;;;;OAIG;IACH,KAAK;CAKR;AAID;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CAGlD;AAED,MAAM,WAAW,SAAS,CAAC,CAAC;IACxB;;OAEG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;IAE7B;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;IAEjB;;;;;;OAMG;IACH,GAAG,CAAC,cAAc,EAAE,CAAC,mBAAmB,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAA;IAEtE;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAA;IAEb;;;OAGG;IACH,UAAU,IAAI,IAAI,CAAA;CACrB;AAWD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAExD;AAED,qBAAa,aAAa,CAAC,CAAC,CAAE,YAAW,SAAS,CAAC,CAAC,CAAC;IAOrC,OAAO,CAAC,QAAQ,CAAC,kBAAkB;IAN/C,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,YAAY,CAAQ;IAC5B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,aAAa,CAAsB;gBAEd,kBAAkB,EAAE,MAAM,CAAC;IAIxD,IAAI,WAAW,IAAI,OAAO,CAEzB;IAED,IAAI,KAAK,IAAI,CAAC,CAGb;IAED,KAAK,IAAI,IAAI;IAYb,UAAU,IAAI,IAAI;IAiBlB,GAAG,CAAC,cAAc,EAAE,CAAC,mBAAmB,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;IAetE,OAAO,CAAC,oBAAoB;IAS5B,OAAO,CAAC,qBAAqB;CAIhC;AA8CD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAExD"}

package/dist/types/current/global/globalRegistry.js

@@ -0,0 +1,181 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { isDisposable } from '../core/disposable';
+import { IllegalStateError } from '../error/IllegalStateError';
+import { remove } from '../util/collection/array';
+/**
+ * Manages global initializers.
+ */
+export class GlobalRegistry {
+    registry = [];
+    /**
+     * Returns the number of references currently in the registry.
+     */
+    get size() {
+        return this.registry.length;
+    }
+    /**
+     * Registers an initializer that will be invoked during global state initialization.
+     * @param initializer
+     */
+    register(initializer) {
+        this.registry.push(initializer);
+        return initializer;
+    }
+    /**
+     * Removes a global ref from the registry.
+     * May be called at any time.
+     * @param ref
+     * @return Returns true if the global ref was removed.
+     */
+    unregister(ref) {
+        return remove(this.registry, ref);
+    }
+    /**
+     * Resets all registered initializers and sets this registry back to its pre-initialized state.
+     * This is typically only done within unit tests, but may be called if all players are
+     * disposed and the consumer intends to teardown global state.
+     */
+    reset() {
+        for (const registryElement of this.registry) {
+            registryElement.reset();
+        }
+    }
+}
+let _registry = null;
+/**
+ * Gets or creates the global registry instance.
+ */
+export function getGlobalRegistry() {
+    if (!_registry)
+        _registry = new GlobalRegistry();
+    return _registry;
+}
+/**
+ * When set, GlobalRefImpl records a stack trace each time it is initialized,
+ * so a later "Cannot call when initialized" error can include the stack of
+ * whoever last touched the ref. Used to diagnose async leakage between specs.
+ *
+ * Tests opt in via setGlobalRefDebug(true).
+ */
+let globalRefDebug = false;
+export function setGlobalRefDebug(enabled) {
+    globalRefDebug = enabled;
+}
+export class GlobalRefImpl {
+    defaultInitializer;
+    _value;
+    _initialized = false;
+    constructing = false;
+    initializer;
+    lastInitStack = null;
+    constructor(defaultInitializer) {
+        this.defaultInitializer = defaultInitializer;
+        this.initializer = defaultInitializer;
+    }
+    get initialized() {
+        return this._initialized;
+    }
+    get value() {
+        this.initialize();
+        return this._value;
+    }
+    reset() {
+        this.initializer = this.defaultInitializer;
+        if (!this._initialized)
+            return;
+        this.assertNotConstructing();
+        this._initialized = false;
+        this.lastInitStack = null;
+        if (isDisposable(this._value)) {
+            this._value.dispose();
+        }
+        this._value = undefined;
+    }
+    initialize() {
+        if (this._initialized)
+            return;
+        this.assertNotConstructing();
+        this.constructing = true;
+        try {
+            this._value = this.initializer();
+        }
+        catch (error) {
+            this.constructing = false;
+            throw error;
+        }
+        this.constructing = false;
+        this._initialized = true;
+        if (globalRefDebug) {
+            this.lastInitStack = new Error('globalRef initialized').stack;
+        }
+    }
+    set(newInitializer) {
+        this.assertNotInitialized();
+        const overriddenInitializer = () => {
+            return newInitializer(this.defaultInitializer);
+        };
+        this.initializer = overriddenInitializer;
+        return new GlobalRefOverride(this, overriddenInitializer, (newInitializer) => {
+            this.initializer = newInitializer;
+        });
+    }
+    assertNotInitialized() {
+        if (this._initialized) {
+            const detail = this.lastInitStack
+                ? `\nLast initialized at:\n${this.lastInitStack}`
+                : '';
+            throw new IllegalStateError(`Cannot call when initialized${detail}`);
+        }
+    }
+    assertNotConstructing() {
+        if (this.constructing)
+            throw new IllegalStateError('Cannot call during construction');
+    }
+}
+class GlobalRefOverride {
+    original;
+    defaultInitializer;
+    setInitializer;
+    initializer;
+    constructor(original, defaultInitializer, setInitializer) {
+        this.original = original;
+        this.defaultInitializer = defaultInitializer;
+        this.setInitializer = setInitializer;
+        this.initializer = defaultInitializer;
+    }
+    get initialized() {
+        return this.original.initialized;
+    }
+    get value() {
+        return this.original.value;
+    }
+    initialize() {
+        this.setInitializer(this.initializer);
+        this.original.initialize();
+    }
+    reset() {
+        this.initializer = this.defaultInitializer;
+        this.original.reset();
+        this.setInitializer(this.initializer);
+    }
+    set(newInitializer) {
+        const overriddenInitializer = () => {
+            return newInitializer(this.defaultInitializer);
+        };
+        this.initializer = overriddenInitializer;
+        this.setInitializer(overriddenInitializer);
+        return new GlobalRefOverride(this, overriddenInitializer, this.setInitializer);
+    }
+}
+/**
+ * Creates a global reference that can be lazily initialized.
+ * This function is tree-shakable as it doesn't perform any side effects on import.
+ *
+ * @param init Factory function that creates the value
+ */
+export function globalRef(init) {
+    return getGlobalRegistry().register(new GlobalRefImpl(init));
+}

package/dist/types/current/global/globalTarget.d.ts

@@ -0,0 +1,8 @@
+import type { LogTarget } from '../logging/LogTarget';
+/**
+ * The global path target.
+ * Global systems such as logging or uncaught error handling may use this when a pathTarget
+ * is needed.
+ */
+export declare const globalTarget: LogTarget;
+//# sourceMappingURL=globalTarget.d.ts.map

package/dist/types/current/global/globalTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalTarget.d.ts","sourceRoot":"","sources":["../../../../src/global/globalTarget.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAEpD;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,SAE1B,CAAA"}

package/dist/types/current/global/globalTarget.js

@@ -0,0 +1,12 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The global path target.
+ * Global systems such as logging or uncaught error handling may use this when a pathTarget
+ * is needed.
+ */
+export const globalTarget = {
+    logPrefix: '<global>',
+};