@zelgadis87/utils-core 4.0.1 → 4.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@zelgadis87/utils-core",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "author": "Zelgadis87",
   "license": "ISC",
   "private": false,

package/src/async/CancelableDeferred.ts

@@ -4,7 +4,7 @@ interface ICancelablePromise<T> extends Promise<T> {
 	cancel(): void;
 }
 
-/** @deprecated use CancelableDeferredV2 instead. */
+/** @deprecated use Deferred instead. */
 export default class CancelableDeferred<T = void> extends Deferred<T> implements ICancelablePromise<T> {
 
 	private _canceled: boolean;

package/src/async/Deferred.ts

@@ -10,7 +10,11 @@ export interface ICancelablePromise<T> extends Promise<T> {
 	cancel(): void;
 }
 
-export class DeferredCanceledError extends Error { }
+export class DeferredCanceledError extends Error {
+	constructor() {
+		super( "Execution canceled" );
+	}
+}
 
 export class Deferred<T = void> implements Promise<T>, ICancelablePromise<T> {
 
@@ -18,7 +22,9 @@ export class Deferred<T = void> implements Promise<T>, ICancelablePromise<T> {
 	private readonly _internals: DeferredInternals<T>;
 
 	public get pending(): boolean { return this._pending; }
-	/** @deprecated: Use resolve, then and catch directly; use asPromise to return a promise type. */ public get promise(): Promise<T> { return this._internals.promise; }
+	
+	/** @deprecated: Use resolve, then and catch directly; use asPromise to return a promise type. */
+	public get promise(): Promise<T> { return this._internals.promise; }
 
 	constructor() {
 		this._pending = true;
@@ -26,16 +32,43 @@ export class Deferred<T = void> implements Promise<T>, ICancelablePromise<T> {
 	}
 
 	public resolve( val: T ): void {
-		if ( !this._pending ) throw new Error( 'Illegal state exception' );
+		if ( !this._pending )
+			throw new Error( 'Illegal state exception' );
+		this.resolveIfPending( val );
+	}
+
+	public reject( reason: Error ): void {
+		if ( !this._pending )
+			throw new Error( 'Illegal state exception' );
+		this.rejectIfPending( reason );
+	}
+
+	public cancel(): void {
+		if ( !this._pending )
+			throw new Error( 'Illegal state exception' );
+		this.cancelIfPending();
+	}
+
+	public resolveIfPending( val: T ): void {
+		if ( !this._pending )
+			return;
 		this._pending = false;
 		this._internals.resolve( val );
 	}
 
-	public reject( reason: Error ): void {
-		if ( !this._pending ) throw new Error( 'Illegal state exception' );
+	public rejectIfPending( reason: Error ): void {
+		if ( !this._pending )
+			return;
 		this._pending = false;
 		this._internals.reject( reason );
 	}
+	
+	public cancelIfPending(): void {
+		if ( !this._pending )
+			return;
+		this.reject( new DeferredCanceledError() );
+	}
+
 
 	public then<R = T, S = T>( onFulfilled: ( ( value: T ) => R | PromiseLike<R> ) | null | undefined, onRejected?: ( ( reason: Error ) => S | PromiseLike<S> ) | null | undefined ): Promise<R | S> {
 		return this._internals.promise.then( onFulfilled, onRejected );
@@ -49,11 +82,6 @@ export class Deferred<T = void> implements Promise<T>, ICancelablePromise<T> {
 		return this._internals.promise.finally( onfinally );
 	}
 
-	public cancel(): void {
-		if ( !this._pending ) throw new Error( 'Illegal state exception' );
-		this._internals.reject( new DeferredCanceledError( 'Execution aborted by the user' ) );
-	}
-
 	public get asPromise(): Promise<T> {
 		return this;
 	}

package/src/async/Semaphore.ts

@@ -3,32 +3,35 @@ import Deferred from "./Deferred";
 
 export class Semaphore {
 
-	private readonly _waitingRequests: Deferred<void>[];
+	private readonly _queuedRequests: Deferred<void>[];
+	private _inProgress = 0;
 
 	constructor(
 		private _availableSlots: number = 1
 	) {
-		this._waitingRequests = [];
+		this._queuedRequests = [];
 	}
 
 	private async _awaitSlot(): Promise<void> {
 		if ( this._availableSlots > 0 ) {
 			this._availableSlots -= 1;
+			this._inProgress += 1;
 			return void 0;
 		} else {
 			// Semaphore implementation using promises.
 			const deferred = new Deferred();
-			this._waitingRequests.push( deferred );
+			this._queuedRequests.push( deferred );
 			return deferred.asPromise;
 		}
 	}
 
 	private _releaseSlot() {
-		const waitingSlotToResolve = this._waitingRequests.shift();
+		const waitingSlotToResolve = this._queuedRequests.shift();
 		if ( waitingSlotToResolve ) {
 			waitingSlotToResolve.resolve();
 		} else {
 			this._availableSlots += 1;
+			this._inProgress -= 1;
 		}
 	}
 
@@ -40,6 +43,18 @@ export class Semaphore {
 			} );
 	}
 
+	public get availableSlots() {
+		return this._availableSlots;
+	}
+
+	public get queueSize() {
+		return this._queuedRequests.length;
+	}
+
+	public get inProgressSize() {
+		return this._inProgress;
+	}
+
 }
 
 export default Semaphore;

package/src/types/empties.ts

@@ -0,0 +1,19 @@
+
+/**
+ * Define a new type that is true if T is the empty object, false otherwise.
+ */
+export type TIsEmptyObject<T> = keyof T extends never ? true : false;
+
+/**
+ * Defines a new type that is the empty array, if T is an empty object, or is the array containing T if T is not the empty object.<br/>
+ * This type can be used as function argument, to conditionally require an argument based on type T.<br/>
+ * Usage example:
+ * ```
+ * type TMetadata = { a: {}, b: {}, c: { x: 1 } };
+ * function foo<X extends keyof TMetadata>( type: X, metadata: TMetadata[X] ) { ... };
+ * export function fooWrapper<X extends keyof TMetadata>( type: X, ...args: TConditionalOptionalType<TMetadata[X]> ) {
+ * 	const bar = foo( type, args.length === 0 ? void 0 : args[ 0 ] );
+ * }
+ * ```
+ */
+export type TConditionalOptionalType<T> = TIsEmptyObject<T> extends true ? [] : [ T ];

package/src/types/index.ts

@@ -8,6 +8,7 @@ export type TPrimitive = string | number | boolean | null;
 
 export * from './arrays';
 export * from './booleans.ts';
+export * from './empties.ts';
 export * from './errors.ts';
 export * from './functions';
 export * from './json';