@zelgadis87/utils-core 4.4.4 → 4.6.0

package/esbuild/package.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "https://json.schemastore.org/package",
+  "name": "@zelgadis87/utils-core",
+  "version": "4.5.0",
+  "author": "Zelgadis87",
+  "license": "ISC",
+  "private": false,
+  "files": [
+    "/src",
+    "/dist",
+    "/esbuild"
+  ],
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./esbuild/index.js",
+      "require": "./esbuild/index.cjs"
+    }
+  },
+  "packageManager": "pnpm@10.0.0+sha512.b8fef5494bd3fe4cbd4edabd0745df2ee5be3e4b0b8b08fa643aa3e4c6702ccc0f00d68fa8a8c9858a735a0032485a44990ed2810526c875e416f001b17df12b",
+  "devDependencies": {
+    "@stylistic/eslint-plugin-ts": "catalog:",
+    "@typescript-eslint/eslint-plugin": "catalog:",
+    "@typescript-eslint/parser": "catalog:",
+    "@vitest/coverage-v8": "catalog:",
+    "@vitest/ui": "catalog:",
+    "esbuild": "catalog:",
+    "eslint": "catalog:",
+    "nx": "catalog:",
+    "rimraf": "catalog:",
+    "typescript": "catalog:",
+    "typescript-eslint": "^8.20.0",
+    "vitest": "catalog:"
+  },
+  "dependencies": {
+    "small-date": "^2.0.1"
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@zelgadis87/utils-core",
-  "version": "4.4.4",
+  "version": "4.6.0",
   "author": "Zelgadis87",
   "license": "ISC",
   "private": false,
@@ -10,117 +10,29 @@
     "/dist",
     "/esbuild"
   ],
-  "wireit": {
-    "build:ts": {
-      "command": "tsc --emitDeclarationOnly",
-      "clean": "if-file-deleted",
-      "files": [
-        "./src/**"
-      ],
-      "output": [
-        "./dist/**"
-      ]
-    },
-    "build:cjs": {
-      "command": "esbuild src/index.ts --bundle --platform=node --target=node18 --format=cjs --outfile=esbuild/index.cjs",
-      "clean": "if-file-deleted",
-      "files": [
-        "./src/**"
-      ],
-      "output": [
-        "./esbuild/index.cjs"
-      ]
-    },
-    "build:esm": {
-      "command": "esbuild src/index.ts --bundle --platform=node --target=node18 --format=esm --outfile=esbuild/index.mjs",
-      "clean": "if-file-deleted",
-      "files": [
-        "./src/**"
-      ],
-      "output": [
-        "./esbuild/index.mjs"
-      ]
-    },
-    "build": {
-      "dependencies": [
-        "build:ts",
-        "build:cjs",
-        "build:esm"
-      ]
-    },
-    "test": {
-      "command": "vitest run --passWithNoTests",
-      "clean": true,
-      "files": [
-        "./src/**/*.ts",
-        "./test/**/*.spec.ts"
-      ],
-      "output": []
-    },
-    "test:coverage": {
-      "command": "vitest run --coverage --passWithNoTests",
-      "clean": true,
-      "files": [
-        "./src/**/*.ts",
-        "./test/**/*.spec.ts"
-      ],
-      "output": [
-        "./coverage/*.*"
-      ]
-    },
-    "lint:strict": {
-      "command": "eslint .",
-      "dependencies": [],
-      "clean": false,
-      "files": [
-        "./*.ts"
-      ],
-      "output": []
-    },
-    "check": {
-      "dependencies": [
-        "lint:strict",
-        "test"
-      ]
-    }
-  },
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./esbuild/index.mjs",
+      "import": "./esbuild/index.js",
       "require": "./esbuild/index.cjs"
     }
   },
   "devDependencies": {
-    "@stylistic/eslint-plugin-ts": "2.9.0",
-    "@typescript-eslint/eslint-plugin": "8.12.2",
-    "@typescript-eslint/parser": "8.12.2",
-    "@vitest/coverage-v8": "^2.1.4",
-    "@vitest/ui": "^2.1.4",
-    "esbuild": "^0.24.0",
-    "eslint": "^9.13.0",
-    "rimraf": "^6.0.1",
-    "typescript": "^5.6.3",
-    "vitest": "^2.1.4",
-    "wireit": "^0.14.9"
+    "@stylistic/eslint-plugin-ts": "2.13.0",
+    "@typescript-eslint/eslint-plugin": "8.20.0",
+    "@typescript-eslint/parser": "8.20.0",
+    "@vitest/coverage-v8": "2.1.8",
+    "@vitest/ui": "2.1.8",
+    "esbuild": "0.24.2",
+    "eslint": "9.18.0",
+    "nx": "20.3.2",
+    "rimraf": "6.0.1",
+    "typescript": "5.7.3",
+    "typescript-eslint": "^8.20.0",
+    "vitest": "2.1.8"
   },
   "dependencies": {
     "small-date": "^2.0.1"
-  },
-  "scripts": {
-    "clean": "rimraf .wireit dist esbuild coverage",
-    "build": "wireit",
-    "lint": "pnpm eslint .",
-    "lint:errors": "pnpm lint --quiet",
-    "lint:strict": "wireit",
-    "test": "wireit",
-    "test:watch": "vitest dev --passWithNoTests",
-    "test:ui": "vitest dev --ui --coverage --passWithNoTests",
-    "test:coverage": "wireit",
-    "test:production": "pnpm test -- -- --allowOnly=false",
-    "check": "wireit",
-    "preversion": "pnpm build && pnpm test:production",
-    "prepublish": "pnpm build && pnpm test:production"
   }
 }

package/src/async/Semaphore.ts

@@ -6,7 +6,11 @@ export class Semaphore {
 	private readonly _queuedRequests: Deferred<void>[];
 	private _inProgress = 0;
 
-	constructor(
+	/** Creates a new Semaphore with a single slot. */
+	public constructor();
+	/** Creates a new Semaphore with the specified amounts of slots. */
+	public constructor( availableSlots: number );
+	public constructor(
 		private _availableSlots: number = 1
 	) {
 		this._queuedRequests = [];
@@ -28,19 +32,17 @@ export class Semaphore {
 	private _releaseSlot() {
 		const waitingSlotToResolve = this._queuedRequests.shift();
 		if ( waitingSlotToResolve ) {
+			// Let the next request start.
 			waitingSlotToResolve.resolve();
 		} else {
+			// Free a slot.
 			this._availableSlots += 1;
 			this._inProgress -= 1;
 		}
 	}
 
 	public async execute<T>( fn: TAsyncProducer<T> | TProducer<T>, cooldown: TimeDuration = TimeDuration.ZERO ) {
-		return this._awaitSlot()
-			.then( () => fn() )
-			.finally( () => {
-				void cooldown.promise().then( () => this._releaseSlot() );
-			} );
+		return this._awaitSlot().then( fn ).finally( () => { void cooldown.delay( () => this._releaseSlot() ); } );
 	}
 
 	public get availableSlots() {

package/src/time/TimeDuration.ts

@@ -46,18 +46,17 @@ export class TimeDuration extends TimeBase<TimeDuration> {
 	}
 
 	/**
-	 * Returns the current duration in a human readable format, prioritizing the most significant unit of time and excluding the rest.
-	 * @todo[2023-06] Should allow more customization options
-	 * @todo[2023-06] By default should show the secondary unit only when actually needed (eg, 1h 20m & 3h, instead of 1h 20m & 3h 28m)
-	 * @todo[2023-06] Should not allow negative durations, as this is a duration and not an instant.
-	 * @returns the duration, with only the most significant units displayed as a human readable string, eg: 1d 20h, 10m 30s.
+		* Returns the current duration in a human readable format, prioritizing the most significant unit of time and excluding the rest.
+		* @todo[2023-06] Should allow more customization options
+		* @todo[2023-06] By default should show the secondary unit only when actually needed (eg, 1h 20m & 3h, instead of 1h 20m & 3h 28m)
+		* @todo[2023-06] Should not allow negative durations, as this is a duration and not an instant.
+		* @returns the duration, with only the most significant units displayed as a human readable string, eg: 1d 20h, 10m 30s.
 	*/
 	public get formatted(): string {
 		const format = ( x: number, u1: string, y: number, u2: string ): string => `${x}${u1} ${pad( y.toString(), 2, '0' )}${u2}`;
 		const units = this.toUnits();
 
-		if ( units.days >= 1 )
-			return format( units.days, 'd', units.hours, 'h' );
+		if ( units.days >= 1 ) return format( units.days, 'd', units.hours, 'h' );
 		else if ( units.hours >= 1 )
 			return format( units.hours, 'h', units.minutes, 'm' );
 		else if ( units.minutes >= 1 )
@@ -85,8 +84,7 @@ export class TimeDuration extends TimeBase<TimeDuration> {
 		return setTimeout( cb, this.ms );
 	}
 
-
-	public promise(): ICancelablePromise<void> {
+	public cancelablePromise(): ICancelablePromise<void> {
 		const deferred = new Deferred<void>;
 		if ( this.ms > 0 ) {
 			this.timeout( () => deferred.resolve() );
@@ -96,8 +94,21 @@ export class TimeDuration extends TimeBase<TimeDuration> {
 		return deferred.asCancelablePromise();
 	}
 
-	public delay( cb: () => unknown ): ICancelable {
-		const deferred = this.promise();
+	public promise(): Promise<void> {
+		if ( this.isEmpty() )
+			return Promise.resolve();
+
+		const deferred = new Deferred<void>;
+		this.timeout( () => deferred.resolve() );
+		return deferred.asPromise();
+	}
+
+	public delay( cb: () => unknown ): void {
+		void this.promise().then( () => cb() );
+	}
+
+	public cancelableDelay( cb: () => unknown ): ICancelable {
+		const deferred = this.cancelablePromise();
 		void deferred.then( () => {
 			cb();
 		}, err => {

package/src/time/TimeInstant.ts

@@ -33,6 +33,16 @@ export class TimeInstant extends TimeBase<TimeInstant> {
 		return TimeDuration.fromMs( Math.abs( this.ms - Date.now() ) );
 	}
 
+	public timeLeftFrom( instant: TimeInstant ): TimeDuration {
+		const distance = this.ms - instant.ms;
+		return TimeDuration.fromMs( Math.max( distance, 0 ) );
+	}
+
+	public timeLeftFromNow(): TimeDuration {
+		const distance = this.ms - Date.now();
+		return TimeDuration.fromMs( Math.max( distance, 0 ) );
+	}
+
 	public distanceFromStartOfDay(): TimeDuration {
 		return this.distanceFrom( this.atStartOfDay() );
 	}
@@ -49,16 +59,20 @@ export class TimeInstant extends TimeBase<TimeInstant> {
 		return this.atTime( { hours: 23, minutes: 59, seconds: 59, milliseconds: 999 } );
 	}
 
-	public promise(): ICancelablePromise<void> {
-		const ms = this.ms - Date.now();
-		const duration = TimeDuration.fromMs( Math.max( ms, 0 ) );
-		return duration.promise();
+	public promise(): Promise<void> {
+		return this.timeLeftFromNow().promise();
+	}
+
+	public cancelablePromise(): ICancelablePromise<void> {
+		return this.timeLeftFromNow().cancelablePromise();
 	}
 
-	public delay( cb: () => unknown ): ICancelable {
-		const ms = this.ms - Date.now();
-		const duration = TimeDuration.fromMs( Math.max( ms, 0 ) );
-		return duration.delay( cb );
+	public delay( cb: () => unknown ): void {
+		return this.timeLeftFromNow().delay( cb );
+	}
+
+	public cancelableDelay( cb: () => unknown ): ICancelable {
+		return this.timeLeftFromNow().cancelableDelay( cb );
 	}
 
 	public ensureInTheFuture() {
@@ -191,22 +205,25 @@ export class TimeInstant extends TimeBase<TimeInstant> {
 	}
 
 	/**
-		* @deprecated[04/07/2023]: Use distanceFromNow instead
-		*/
+	 * @deprecated: Use {@link distanceFromNow} instead
+	*/
+	// TODO[2023-07-04, Deprecated]: Remove this method in a future version
 	public fromNow(): TimeDuration {
 		return TimeDuration.ms( this.ms - Date.now() );
 	}
 
 	/**
-		* @deprecated[04/07/2023]: Use distanceFrom instead
-		*/
+	 * @deprecated: Use {@link distanceFrom} instead
+	*/
+	// TODO[2023-07-04, Deprecated]: Remove this method in a future version
 	public from( instant: TimeInstant ): TimeDuration {
 		return TimeDuration.ms( this.ms - instant.ms );
 	}
 
 	/**
-		* @deprecated[04/07/2023]: Use distanceFromUnixTimestamp instead
-		*/
+	 * @deprecated: Use {@link distanceFromUnixTimestamp} instead
+	*/
+	// TODO[2023-07-04, Deprecated]: Remove this method in a future version
 	public fromTimestamp( timestamp: number ): TimeDuration {
 		return TimeDuration.ms( this.ms - timestamp );
 	}
@@ -260,8 +277,8 @@ export class TimeInstant extends TimeBase<TimeInstant> {
 	}
 
 	/**
-		* @deprecated[19/07/2023] Use {@link fromParameters} instead.
-		*/
+	 * @deprecated[19/07/2023] Use {@link fromParameters} instead.
+	 */
 	public static fromUnits( { date, month, year, hours, minutes, seconds }: { date: number, month: number, year: number, hours?: number, minutes?: number, seconds?: number } ): TimeInstant {
 		const dt = Date.UTC( year, month - 1, date, hours ?? 0, minutes ?? 0, seconds ?? 0 );
 		if ( isNaN( dt ) )
@@ -334,15 +351,15 @@ export class TimeInstant extends TimeBase<TimeInstant> {
 	}
 
 	/**
-		* Returns the week number represented by this instant, according to the ISO 8601 standard.
+	 * Returns the week number represented by this instant, according to the ISO 8601 standard.
 		* Please note that the instant and the week number could be of two different years, eg the friday 1st january is actually part of week 52 of the previous year.
-		*/
+	 */
 	public get weekNumber(): { weekNumber: TWeekNumber, year: number } {
 		/**
 			* According to the ISO 8601 Standard, week number 1 is defined as the week containing the 4th of january (or, equivalently, the week that contains the first Thursday of the year).
 			* As such, we basically have to count how many Thursdays there has been in this year.
 			* Please note that the thursdayOfThisWeek could be in the previous year.
-			*/
+		 */
 		const date = this.toDate();
 		const oneDay = 1000 * 60 * 60 * 24;
 		const thursdayOfThisWeek = new Date( date.getFullYear(), date.getMonth(), date.getDate() + 4 - ( date.getDay() || 7 ), 14, 0, 0 );
@@ -353,8 +370,8 @@ export class TimeInstant extends TimeBase<TimeInstant> {
 	}
 
 	/**
-		* This method is used to provide a better DX when inspecting a TimeInstant object in DevTools.
-		*/
+	 * This method is used to provide a better DX when inspecting a TimeInstant object in DevTools.
+	 */
 	protected get _time() {
 		return this.asHumanTimestamp();
 	}

package/src/utils/arrays/groupBy.ts

@@ -1,40 +1,40 @@
 
-import { TFunction, TKeysOfType } from "..";
+import { TFunction, TKeysOfType, TReadableArray } from "..";
 
-export function groupByString<V, K extends TKeysOfType<V, string>>( arr: V[], field: K ): Record<V[K] & string, V[]> {
+export function groupByString<V, K extends TKeysOfType<V, string>>( arr: TReadableArray<V>, field: K ): Record<V[ K ] & string, V[]> {
 	return groupByStringWith( arr, t => t[ field ] as string );
 }
 
-export function groupByNumber<V, K extends TKeysOfType<V, number>>( arr: V[], field: K ): Record<V[K] & number, V[]> {
+export function groupByNumber<V, K extends TKeysOfType<V, number>>( arr: TReadableArray<V>, field: K ): Record<V[ K ] & number, V[]> {
 	return groupByNumberWith( arr, t => t[ field ] as number );
 }
 
-export function groupByBoolean<V, K extends TKeysOfType<V, boolean>>( arr: V[], field: K ): Record<"true" | "false", V[]> {
+export function groupByBoolean<V, K extends TKeysOfType<V, boolean>>( arr: TReadableArray<V>, field: K ): Record<"true" | "false", V[]> {
 	return groupByBooleanWith( arr, t => t[ field ] as boolean );
 }
 
-export function groupBySymbol<V, K extends TKeysOfType<V, symbol>>( arr: V[], field: K ): Record<V[K] & symbol, V[]> {
+export function groupBySymbol<V, K extends TKeysOfType<V, symbol>>( arr: TReadableArray<V>, field: K ): Record<V[ K ] & symbol, V[]> {
 	return groupBySymbolWith( arr, t => t[ field ] as symbol );
 }
 
-export function groupByStringWith<V, K extends string>( arr: V[], getter: TFunction<V, K> ): Record<K, V[]> {
+export function groupByStringWith<V, K extends string>( arr: TReadableArray<V>, getter: TFunction<V, K> ): Record<K, V[]> {
 	return doGroupByWith<K, V>( arr, getter );
 }
 
-export function groupByNumberWith<V, K extends number>( arr: V[], getter: TFunction<V, K> ): Record<K, V[]> {
+export function groupByNumberWith<V, K extends number>( arr: TReadableArray<V>, getter: TFunction<V, K> ): Record<K, V[]> {
 	return doGroupByWith<K, V>( arr, getter );
 }
 
-export function groupByBooleanWith<V, K extends boolean>( arr: V[], getter: TFunction<V, K> ): Record<"true" | "false", V[]> {
+export function groupByBooleanWith<V, K extends boolean>( arr: TReadableArray<V>, getter: TFunction<V, K> ): Record<"true" | "false", V[]> {
 	return doGroupByWith<"true" | "false", V>( arr, item => getter( item ) ? "true" : "false" );
 }
 
-export function groupBySymbolWith<V, K extends symbol>( arr: V[], getter: TFunction<V, K> ): Record<K, V[]> {
+export function groupBySymbolWith<V, K extends symbol>( arr: TReadableArray<V>, getter: TFunction<V, K> ): Record<K, V[]> {
 	return doGroupByWith<K, V>( arr, getter );
 }
 
-function doGroupByWith<K extends string | number | symbol, V>( arr: V[], getter: TFunction<V, K> ): Record<K, V[]> {
-	return arr.reduce( ( dict, cur ) => {
+function doGroupByWith<K extends string | number | symbol, V>( arr: TReadableArray<V>, getter: TFunction<V, K> ): Record<K, V[]> { // TODO[2025-01-03, Native]: Migrate to native @ https://devblogs.microsoft.com/typescript/announcing-typescript-5-4/#object.groupby-and-map.groupby
+	return [ ...arr ].reduce( ( dict, cur ) => {
 		const key = getter( cur );
 		if ( key !== null && key !== undefined ) {
 			const arr = dict[ key ] ?? [];

package/src/utils/arrays.ts

@@ -1,6 +1,6 @@
 import type { TComparisonFunction } from "../sorting/index.js";
 import type { TAccumulator, TBiPredicate, TPredicate, TTransformer } from "./functions.js";
-import type { TMaybe } from "./nulls.js";
+import { isNullOrUndefined, type TMaybe } from "./nulls.js";
 
 export * from './arrays/groupBy.js';
 export * from './arrays/indexBy.js';
@@ -11,10 +11,12 @@ export type TReadableArray<T> = Array<T> | ReadonlyArray<T>;
 export type TArrayable<T> = T | T[];
 export type TEmptyArray = [];
 
-export function ensureArray<const T>( t: T | Array<T> ): Array<T> {
+export function ensureArray<const T>( t: T | Array<T> | null | undefined ): Array<T> {
+	if ( isNullOrUndefined( t ) ) return [];
 	return t instanceof Array ? t : [ t ];
 }
-export function ensureReadableArray<const T>( t: T | Array<T> | ReadonlyArray<T> ): TReadableArray<T> {
+export function ensureReadableArray<const T>( t: T | Array<T> | ReadonlyArray<T> | null | undefined ): TReadableArray<T> {
+	if ( isNullOrUndefined( t ) ) return [];
 	return t instanceof Array ? t : [ t ];
 }
 
@@ -138,3 +140,7 @@ export function mapFirstTruthy<T, R>(arr: T[], mapFn: TTransformer<T, R>): R | n
 	}
 	return null;
 }
+
+export function makeArrayEmpty( arr: unknown[] ): void {
+	arr.splice( 0, arr.length );
+}

package/src/utils/functions/constant.ts

@@ -5,5 +5,7 @@ export default constant;
 export const constantNull = constant( null );
 export const constantTrue = constant( true );
 export const constantFalse = constant( false );
+export const alwaysTrue = constantTrue;
+export const alwaysFalse = constantFalse;
 export const constantZero = constant( 0 );
 export const constantOne = constant( 1 );

package/src/utils/functions.ts

@@ -1,3 +1,4 @@
+import { constantTrue } from './functions.js';
 
 export * from './functions/constant.js';
 export * from './functions/iff.js';
@@ -38,4 +39,26 @@ export function filterWithTypePredicate<T, R extends T>( filter: TPredicate<T> )
 	return ( t: T ): t is R => filter( t );
 }
 
+export function not<T>( predicate: TPredicate<T> ): TPredicate<T> {
+	return ( t: T ) => !predicate( t );
+}
+
+export function and<T>( a: TPredicate<T>, b: TPredicate<T> ): TPredicate<T>;
+export function and<T>( ...predicates: Array<TPredicate<T>> ): TPredicate<T> {
+	if ( predicates.length === 0 ) return constantTrue;
+	else if ( predicates.length === 1 ) return predicates[ 0 ];
+	return ( t: T ) => predicates.reduce( ( prev, cur ) => prev ? cur( t ) : false, true );
+}
+
+export function or<T>( a: TPredicate<T>, b: TPredicate<T> ): TPredicate<T>;
+export function or<T>( ...predicates: Array<TPredicate<T>> ): TPredicate<T> {
+	if ( predicates.length === 0 ) return constantTrue;
+	else if ( predicates.length === 1 ) return predicates[ 0 ];
+	return ( t: T ) => predicates.reduce( ( prev, cur ) => prev ? true : cur( t ), false );
+}
+
+export function xor<T>( a: TPredicate<T>, b: TPredicate<T> ): TPredicate<T> {
+	return ( t: T ) => a( t ) !== b( t );
+}
+
 

package/src/utils/random.ts

@@ -1,9 +1,15 @@
+import { TPositiveNumber } from "./numbers.ts";
 
+/** @deprecated[2025-01-14]: Use {@link randomNumberInInterval} instead. */
+export const randomInterval = ( min: number, max: number ): number => randomNumberInInterval( min, max );
 
-export function randomInterval( min: number, max: number ): number {
+/** @deprecated[2025-01-14]: Use {@link randomNumberInInterval} / 100 instead. */
+export const randomPercentage = ( min: number, max: number ): number => randomNumberInInterval( min, max ) / 100;
+
+export function randomNumberInInterval( min: number, max: number ): number {
 	return Math.floor( Math.random() * ( max - min + 1 ) + min );
 }
 
-export function randomPercentage( min: number, max: number ): number {
-	return randomInterval( min, max ) / 100;
+export const randomId = ( length: TPositiveNumber ): string => {
+	return Math.random().toString(36).substring(2, length + 2);
 }

package/src/utils/records.ts

@@ -26,3 +26,15 @@ export type TConditionalParameterOptions<T, R> = TConditionalParameter<TOptionsW
  * Given a type T, replaces all fields of type From to fields of type To.
  */
 export type TReplaceType<T, From, To> = { [ K in keyof T ]: T[ K ] extends From ? To : T[ K ]; };
+
+/**
+ * Given a type T, make field K required instead of optional.
+ */
+export type TWithRequiredProperty<T, K extends keyof T> = T & {
+	[ Property in K ]-?: T[ Property ];
+};
+
+/**
+ * Given a type T, make all fields required instead of optional.
+ */
+export type TWithRequiredProperties<T> = Required<T>;

package/dist/Logger.d.ts

@@ -1,21 +0,0 @@
-declare const LEVELS: readonly ["log", "debug", "info", "warn", "error"];
-type TLogLevel = keyof Console & typeof LEVELS[number];
-export type TLoggerOpts = {
-    console: Console;
-    enabled: boolean;
-    minLevel: Uppercase<TLogLevel>;
-};
-export declare class Logger {
-    readonly name: string;
-    private enabled;
-    private console;
-    private minLevel;
-    constructor(name: string, args?: Partial<TLoggerOpts>);
-    get log(): (...args: any[]) => void;
-    get debug(): (...args: any[]) => void;
-    get info(): (...args: any[]) => void;
-    get warn(): (...args: any[]) => void;
-    get error(): (...args: any[]) => void;
-    private logWrap;
-}
-export default Logger;

package/dist/Optional.d.ts

@@ -1,70 +0,0 @@
-import { TConsumer, TFunction, TPredicate, TProducer, TVoidFunction } from "./utils/functions.js";
-export declare class Optional<T> implements TOptional<T> {
-    private _present;
-    private _value;
-    private constructor();
-    get rawValue(): T | undefined;
-    get(): T | never;
-    set(t: T): void;
-    clear(): void;
-    isEmpty(): this is TEmptyOptional<T>;
-    isPresent(): this is TPresentOptional<T>;
-    ifEmpty(callback: TVoidFunction): void;
-    ifPresent(callback: TConsumer<T>): void;
-    apply(callbackIfPresent: TConsumer<T>, callbackIfEmpty: TVoidFunction): void;
-    orElse(newValue: T | null | undefined): any;
-    orElseGet(produceValue: TProducer<T | null | undefined>): TOptional<T>;
-    orElseThrow(produceError: TProducer<Error>): TPresentOptional<T>;
-    mapTo<R>(mapper: TFunction<T, R | null | undefined>): any;
-    flatMapTo<R>(mapper: TFunction<T, TOptional<R>>): any;
-    filter(predicate: TPredicate<T>): this | TEmptyOptional<T>;
-    static empty<T>(): TEmptyOptional<T>;
-    static of<T>(t: T): TPresentOptional<T>;
-    static ofNullable<T>(t: T | null | undefined): TOptional<T>;
-}
-export default Optional;
-export type TOptional<T> = {
-    readonly rawValue: T | undefined;
-    /**
-     * @returns the currently stored value, if any; throws {@link ErrorGetEmptyOptional} otherwise;
-     */
-    get(): T | never;
-    /**
-     * Places a new value inside this optional. Throws {@link ErrorSetEmptyOptional} if t is null or undefined.
-     */
-    set(t: T): void;
-    /**
-     * Clears the current value from this optional, if any.
-     */
-    clear(): void;
-    isEmpty(): boolean;
-    isPresent(): boolean;
-    ifEmpty: (callback: TVoidFunction) => void;
-    ifPresent: (callback: TConsumer<T>) => void;
-    apply(callbackIfPresent: TConsumer<T>, callbackIfEmpty: TVoidFunction): void;
-    orElse: ((newValue: T | null | undefined) => TOptional<T>);
-    orElseGet: (produceValue: TProducer<T | null | undefined>) => TOptional<T>;
-    orElseThrow: (produceError: TProducer<Error>) => TPresentOptional<T>;
-    mapTo<R>(mapper: TFunction<T, R>): TOptional<R>;
-    flatMapTo<R>(mapper: TFunction<T, TOptional<R>>): TOptional<R>;
-    filter(predicate: TPredicate<T>): TOptional<T>;
-};
-export type TEmptyOptional<T> = TOptional<T> & {
-    readonly rawValue: undefined;
-    isEmpty(): true;
-    isPresent(): false;
-};
-export type TPresentOptional<T> = TOptional<T> & {
-    readonly rawValue: T;
-    isEmpty(): false;
-    isPresent(): true;
-};
-export declare class ErrorGetEmptyOptional extends Error {
-    constructor();
-}
-export declare class ErrorSetEmptyOptional extends Error {
-    constructor();
-}
-export declare class ErrorCannotInstantiatePresentOptionalWithEmptyValue extends Error {
-    constructor();
-}

package/dist/async/CancelableDeferred.d.ts

@@ -1,17 +0,0 @@
-import Deferred from "./Deferred.js";
-interface ICancelablePromise<T> extends Promise<T> {
-    cancel(): void;
-}
-/** @deprecated use Deferred instead. */
-export default class CancelableDeferred<T = void> extends Deferred<T> implements ICancelablePromise<T> {
-    private _canceled;
-    get canceled(): boolean;
-    constructor();
-    cancel(): void;
-    protected createInternals(): {
-        promise: Promise<T>;
-        resolve: (value: T) => void;
-        reject: (reason: Error) => void;
-    };
-}
-export {};