/proc/self/root/var/runtime/node_modules/@aws-sdk/node_modules/aws-crt/lib/common
This explorer reads the filesystem of the server it runs on, so /workspace/user isn't present here. Browsing and the terminal still work against this server's own disk from /.
/* * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ /** * * A module containing support for cancelling asynchronous operations * * @packageDocumentation * @module cancel */ import {EventEmitter} from "events";import * as promise from "./promise"; /** * Callback signature for when cancel() has been invoked on a CancelController */export type CancelListener = () => void; /** * Abstract interface for an object capable of cancelling asynchronous operations. * * Modern browsers and Node 15+ include an AbortController which essentially does the same thing. But our baseline * is still node 10, so we provide our own implementation. Also, Abort is, unfortunately, a problematic term, so we * stick to Cancel. */export interface ICancelController { /** * API to invoke to cancel all asynchronous operations connected to this controller */ cancel() : void; /** * Checks whether or not the controller is in the cancelled state */ hasBeenCancelled() : boolean; /** * Registers a callback to be notified when cancel() is invoked externally. In general, the callback * will cancel an asynchronous operation by rejecting the associated promise. * * IMPORTANT: The listener is invoked synchronously if the controller has already been cancelled. * * @param listener - function to invoke on cancel; invoked synchronously if the controller has already been * cancelled * * @return undefined if the controller has already been cancelled, otherwise a function object whose invocation * will remove the listener from the controller's event emitter. * */ addListener(listener: CancelListener) : promise.PromiseCleanupFunctor | undefined; } export const EVENT_NAME = 'cancelled'; /** * Signature for a factory function that can create EventEmitter objects */export type EventEmitterFactory = () => EventEmitter; /** * Configuration options for the CRT implementation of ICancelController */export interface CancelControllerOptions { /** * Event emitters have, by default, a small maximum number of listeners. When that default is insufficient for * a use case, this factory option allows for customization of how the internal event emitter is created. */ emitterFactory? : EventEmitterFactory;} /** * CRT implementation of the ICancelController interface */export class CancelController implements ICancelController { private cancelled : boolean; private emitter : EventEmitter; public constructor(options?: CancelControllerOptions) { this.cancelled = false; if (options && options.emitterFactory) { this.emitter = options.emitterFactory(); } else { this.emitter = new EventEmitter(); } } /** * Cancels all asynchronous operations associated with this controller */ public cancel() { if (!this.cancelled) { this.cancelled = true; this.emitter.emit(EVENT_NAME); this.emitter.removeAllListeners(EVENT_NAME); } } /** * Checks whether or not the controller is in the cancelled state */ public hasBeenCancelled() { return this.cancelled; } /** * Registers a callback to be notified when cancel() is invoked externally. In general, the callback * will cancel an asynchronous operation by rejecting the associated promise. * * IMPORTANT: The listener is invoked synchronously if the controller has already been cancelled. * * @param listener - function to invoke on cancel; invoked synchronously if the controller has been cancelled * * @return undefined if the controller has already been cancelled, otherwise a function object whose invocation * will remove the listener from the controller's event emitter. * */ public addListener(listener: CancelListener) : promise.PromiseCleanupFunctor | undefined { if (this.cancelled) { listener(); return undefined; } this.emitter.on(EVENT_NAME, listener); return () => { this.emitter.removeListener(EVENT_NAME, listener); }; } } /** * Configuration options for creating a promise that can be rejected by cancellation and resolved by the receipt * of an event from an EventEmitter. */export interface CancellableNextEventPromiseOptions<ResultType> { /** * Optional cancel controller that can cancel the created promise */ cancelController? : ICancelController; /** * Event emitter to listen to for potential promise completion */ emitter : EventEmitter; /** * Name of the event to listen on for potential promise completion */ eventName : string; /** * Optional transformation function for the event payload */ eventDataTransformer? : (eventData : any) => ResultType; /** * Message to reject the promise with if cancellation is invoked */ cancelMessage? : string;} /** * Creates a promise that can be rejected by a CancelController and resolved by the receipt of an event from an * EventEmitter. * * @param config promise creation options */export function newCancellablePromiseFromNextEvent<ResultType>(config: CancellableNextEventPromiseOptions<ResultType>) : Promise<ResultType> { let onEvent : ((eventData : any) => void) | undefined = undefined; let cancelRemoveListener : promise.PromiseCleanupFunctor | undefined = undefined; let liftedPromise : promise.LiftedPromise<ResultType> = promise.newLiftedPromise<ResultType>(); onEvent = (eventData : any) => { try { if (config.eventDataTransformer) { liftedPromise.resolve(config.eventDataTransformer(eventData)); } else { liftedPromise.resolve(eventData as ResultType); } } catch (err) { liftedPromise.reject(err); } } config.emitter.addListener(config.eventName, onEvent); if (config.cancelController) { cancelRemoveListener = config.cancelController.addListener(() => { liftedPromise.reject(config.cancelMessage); }); } return promise.makeSelfCleaningPromise(liftedPromise.promise, () => { if (onEvent) { config.emitter.removeListener(config.eventName, onEvent); } if (cancelRemoveListener) { cancelRemoveListener(); } });}