Add changes from hey-api/openapi-ts#171 to fix #1992

Author: Lamarcke

README.md

@@ -1,20 +1,3 @@
-# Important announcement
-
-> [!IMPORTANT] 
-> Please migrate your projects to use [@hey-api/openapi-ts](https://github.com/hey-api/openapi-ts)
-
-Due to time limitations on my end, this project has been unmaintained for a while now. The `@hey-api/openapi-ts`
-project started as a fork with the goal to resolve the most pressing issues. going forward they are planning to
-maintain the OpenAPI generator and give it the love it deserves. Please support them with their work and make
-sure to migrate your projects: https://heyapi.dev/openapi-ts/migrating.html#openapi-typescript-codegen
-
-- All open PR's and issues will be archived on the 1st of May 2024
-- All versions of this package will be deprecated in NPM
-
-👋 Thanks for all the support, downloads and love! Cheers Ferdi.
-
----
-
 # OpenAPI Typescript Codegen
 
 [![NPM][npm-image]][npm-url]

src/templates/core/CancelablePromise.hbs

@@ -21,62 +21,62 @@ export interface OnCancel {
 }
 
 export class CancelablePromise<T> implements Promise<T> {
-	#isResolved: boolean;
-	#isRejected: boolean;
-	#isCancelled: boolean;
-	readonly #cancelHandlers: (() => void)[];
-	readonly #promise: Promise<T>;
-	#resolve?: (value: T | PromiseLike<T>) => void;
-	#reject?: (reason?: any) => void;
+	private _isResolved: boolean;
+	private _isRejected: boolean;
+	private _isCancelled: boolean;
+	readonly cancelHandlers: (() => void)[];
+	readonly promise: Promise<T>;
+	private _resolve?: (value: T | PromiseLike<T>) => void;
+	private _reject?: (reason?: unknown) => void;
 
 	constructor(
 		executor: (
 			resolve: (value: T | PromiseLike<T>) => void,
-			reject: (reason?: any) => void,
+			reject: (reason?: unknown) => void,
 			onCancel: OnCancel
 		) => void
 	) {
-		this.#isResolved = false;
-		this.#isRejected = false;
-		this.#isCancelled = false;
-		this.#cancelHandlers = [];
-		this.#promise = new Promise<T>((resolve, reject) => {
-			this.#resolve = resolve;
-			this.#reject = reject;
+		this._isResolved = false;
+		this._isRejected = false;
+		this._isCancelled = false;
+		this.cancelHandlers = [];
+		this.promise = new Promise<T>((resolve, reject) => {
+			this._resolve = resolve;
+			this._reject = reject;
 
 			const onResolve = (value: T | PromiseLike<T>): void => {
-				if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+				if (this._isResolved || this._isRejected || this._isCancelled) {
 					return;
 				}
-				this.#isResolved = true;
-				if (this.#resolve) this.#resolve(value);
+				this._isResolved = true;
+				if (this._resolve) this._resolve(value);
 			};
 
-			const onReject = (reason?: any): void => {
-				if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+			const onReject = (reason?: unknown): void => {
+				if (this._isResolved || this._isRejected || this._isCancelled) {
 					return;
 				}
-				this.#isRejected = true;
-				if (this.#reject) this.#reject(reason);
+				this._isRejected = true;
+				if (this._reject) this._reject(reason);
 			};
 
 			const onCancel = (cancelHandler: () => void): void => {
-				if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+				if (this._isResolved || this._isRejected || this._isCancelled) {
 					return;
 				}
-				this.#cancelHandlers.push(cancelHandler);
+				this.cancelHandlers.push(cancelHandler);
 			};
 
 			Object.defineProperty(onCancel, 'isResolved', {
-				get: (): boolean => this.#isResolved,
+				get: (): boolean => this._isResolved,
 			});
 
 			Object.defineProperty(onCancel, 'isRejected', {
-				get: (): boolean => this.#isRejected,
+				get: (): boolean => this._isRejected,
 			});
 
 			Object.defineProperty(onCancel, 'isCancelled', {
-				get: (): boolean => this.#isCancelled,
+				get: (): boolean => this._isCancelled,
 			});
 
 			return executor(onResolve, onReject, onCancel as OnCancel);
@@ -89,41 +89,41 @@ export class CancelablePromise<T> implements Promise<T> {
 
 	public then<TResult1 = T, TResult2 = never>(
 		onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
-		onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
+		onRejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null
 	): Promise<TResult1 | TResult2> {
-		return this.#promise.then(onFulfilled, onRejected);
+		return this.promise.then(onFulfilled, onRejected);
 	}
 
 	public catch<TResult = never>(
-		onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null
+		onRejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null
 	): Promise<T | TResult> {
-		return this.#promise.catch(onRejected);
+		return this.promise.catch(onRejected);
 	}
 
 	public finally(onFinally?: (() => void) | null): Promise<T> {
-		return this.#promise.finally(onFinally);
+		return this.promise.finally(onFinally);
 	}
 
 	public cancel(): void {
-		if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+		if (this._isResolved || this._isRejected || this._isCancelled) {
 			return;
 		}
-		this.#isCancelled = true;
-		if (this.#cancelHandlers.length) {
+		this._isCancelled = true;
+		if (this.cancelHandlers.length) {
 			try {
-				for (const cancelHandler of this.#cancelHandlers) {
+				for (const cancelHandler of this.cancelHandlers) {
 					cancelHandler();
 				}
 			} catch (error) {
 				console.warn('Cancellation threw an error', error);
 				return;
 			}
 		}
-		this.#cancelHandlers.length = 0;
-		if (this.#reject) this.#reject(new CancelError('Request aborted'));
+		this.cancelHandlers.length = 0;
+		if (this._reject) this._reject(new CancelError('Request aborted'));
 	}
 
 	public get isCancelled(): boolean {
-		return this.#isCancelled;
+		return this._isCancelled;
 	}
 }