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;
 }
 }