Removed private fields using new # syntax due to issues

Author: ferdikoomen

CHANGELOG.md

@@ -1,10 +1,11 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
-## [0.20.2] - 2022-02-25
+## [0.21.0] - 2022-04-06
 ### Fixed
 - Return `undefined` to match `noImplicitReturns` rule
 - Made `BaseHttpRequest` class abstract
+- Removed private fields using `#` inside `CancelablePromise`
 - Filter out wrong enum values
 
 ## [0.20.1] - 2022-02-25

src/openApi/v2/parser/getEnum.ts

@@ -24,7 +24,7 @@ export const getEnum = (values?: (string | number)[]): Enum[] => {
                         .replace(/^(\d+)/g, '_$1')
                         .replace(/([a-z])([A-Z]+)/g, '$1_$2')
                         .toUpperCase(),
-                    value: `'${value.replace(/'/g, '\\\'')}'`,
+                    value: `'${value.replace(/'/g, "\\'")}'`,
                     type: 'string',
                     description: null,
                 };

src/openApi/v3/parser/getEnum.ts

@@ -24,7 +24,7 @@ export const getEnum = (values?: (string | number)[]): Enum[] => {
                         .replace(/^(\d+)/g, '_$1')
                         .replace(/([a-z])([A-Z]+)/g, '$1_$2')
                         .toUpperCase(),
-                    value: `'${value.replace(/'/g, '\\\'')}'`,
+                    value: `'${value.replace(/'/g, "\\'")}'`,
                     type: 'string',
                     description: null,
                 };

src/templates/core/CancelablePromise.hbs

@@ -23,13 +23,13 @@ export interface OnCancel {
 export class CancelablePromise<T> implements Promise<T> {
 	readonly [Symbol.toStringTag]: string;
 
-	#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;
+	private readonly _cancelHandlers: (() => void)[];
+	private readonly _promise: Promise<T>;
+	private _resolve?: (value: T | PromiseLike<T>) => void;
+	private _reject?: (reason?: any) => void;
 
 	constructor(
 		executor: (
@@ -38,47 +38,47 @@ export class CancelablePromise<T> implements Promise<T> {
 			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;
-				this.#resolve?.(value);
+				this._isResolved = true;
+				this._resolve?.(value);
 			};
 
 			const onReject = (reason?: any): void => {
-				if (this.#isResolved || this.#isRejected || this.#isCancelled) {
+				if (this._isResolved || this._isRejected || this._isCancelled) {
 					return;
 				}
-				this.#isRejected = true;
-				this.#reject?.(reason);
+				this._isRejected = true;
+				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,39 +89,39 @@ export class CancelablePromise<T> implements Promise<T> {
 		onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
 		onRejected?: ((reason: any) => 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
 	): 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;
-		this.#reject?.(new CancelError('Request aborted'));
+		this._cancelHandlers.length = 0;
+		this._reject?.(new CancelError('Request aborted'));
 	}
 
 	public get isCancelled(): boolean {
-		return this.#isCancelled;
+		return this._isCancelled;
 	}
 }